<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML+RDFa 1.1//EN' 'http://www.w3.org/MarkUp/DTD/xhtml-rdfa-2.dtd'>
<html dir="ltr" about="" property="dcterms:language" content="en" xmlns="http://www.w3.org/1999/xhtml" prefix='bibo: http://purl.org/ontology/bibo/' typeof="bibo:Document">
<head>
<title>The JSON-LD API 1.0</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />

<!-- 
  === NOTA BENE ===
  For the three scripts below, if your spec resides on dev.w3 you can check them
  out in the same tree and use relative links so that they'll work offline,
   -->



<style type="text/css">
.diff { font-weight:bold; color:#0a3; }
ol.algorithm.update { margin-left: 2em; }
ol.algorithm.update>li { list-style-type: none; }
ol.algorithm.update>li>span.list-number {
  display:block;
  float: left;
  margin-left: -3.5em;
}
</style>
<style type="text/css">
/*****************************************************************
 * ReSpec CSS
 * Robin Berjon (robin at berjon dot com)
 * v0.05 - 2009-07-31
 *****************************************************************/


/* --- INLINES --- */
em.rfc2119 { 
    text-transform:     lowercase;
    font-variant:       small-caps;
    font-style:         normal;
    color:              #900;
}

h1 acronym, h2 acronym, h3 acronym, h4 acronym, h5 acronym, h6 acronym, a acronym,
h1 abbr, h2 abbr, h3 abbr, h4 abbr, h5 abbr, h6 abbr, a abbr {
    border: none;
}

dfn {
    font-weight:    bold;
}

a.internalDFN {
    color:  inherit;
    border-bottom:  1px solid #99c;
    text-decoration:    none;
}

a.externalDFN {
    color:  inherit;
    border-bottom:  1px dotted #ccc;
    text-decoration:    none;
}

a.bibref {
    text-decoration:    none;
}

code {
    color:  #ff4500;
}


/* --- WEB IDL --- */
pre.idl {
    border-top: 1px solid #90b8de;
    border-bottom: 1px solid #90b8de;
    padding:    1em;
    line-height:    120%;
}

pre.idl::before {
    content:    "WebIDL";
    display:    block;
    width:      150px;
    background: #90b8de;
    color:  #fff;
    font-family:    initial;
    padding:    3px;
    font-weight:    bold;
    margin: -1em 0 1em -1em;
}

.idlType {
    color:  #ff4500;
    font-weight:    bold;
    text-decoration:    none;
}

/*.idlModule*/
/*.idlModuleID*/
/*.idlInterface*/
.idlInterfaceID, .idlDictionaryID {
    font-weight:    bold;
    color:  #005a9c;
}

.idlSuperclass {
    font-style: italic;
    color:  #005a9c;
}

/*.idlAttribute*/
.idlAttrType, .idlFieldType, .idlMemberType {
    color:  #005a9c;
}
.idlAttrName, .idlFieldName, .idlMemberName {
    color:  #ff4500;
}
.idlAttrName a, .idlFieldName a, .idlMemberName a {
    color:  #ff4500;
    border-bottom:  1px dotted #ff4500;
    text-decoration: none;
}

/*.idlMethod*/
.idlMethType {
    color:  #005a9c;
}
.idlMethName {
    color:  #ff4500;
}
.idlMethName a {
    color:  #ff4500;
    border-bottom:  1px dotted #ff4500;
    text-decoration: none;
}

/*.idlParam*/
.idlParamType {
    color:  #005a9c;
}
.idlParamName {
    font-style: italic;
}

.extAttr {
    color:  #666;
}

/*.idlConst*/
.idlConstType {
    color:  #005a9c;
}
.idlConstName {
    color:  #ff4500;
}
.idlConstName a {
    color:  #ff4500;
    border-bottom:  1px dotted #ff4500;
    text-decoration: none;
}

/*.idlException*/
.idlExceptionID {
    font-weight:    bold;
    color:  #c00;
}

.idlTypedefID, .idlTypedefType {
    color:  #005a9c;
}

.idlRaises, .idlRaises a.idlType, .idlRaises a.idlType code, .excName a, .excName a code {
    color:  #c00;
    font-weight:    normal;
}

.excName a {
    font-family:    monospace;
}

.idlRaises a.idlType, .excName a.idlType {
    border-bottom:  1px dotted #c00;
}

.excGetSetTrue, .excGetSetFalse, .prmNullTrue, .prmNullFalse, .prmOptTrue, .prmOptFalse {
    width:  45px;
    text-align: center;
}
.excGetSetTrue, .prmNullTrue, .prmOptTrue { color:  #0c0; }
.excGetSetFalse, .prmNullFalse, .prmOptFalse { color:  #c00; }

.idlImplements a {
    font-weight:    bold;
}

dl.attributes, dl.methods, dl.constants, dl.fields, dl.dictionary-members {
    margin-left:    2em;
}

.attributes dt, .methods dt, .constants dt, .fields dt, .dictionary-members dt {
    font-weight:    normal;
}

.attributes dt code, .methods dt code, .constants dt code, .fields dt code, .dictionary-members dt code {
    font-weight:    bold;
    color:  #000;
    font-family:    monospace;
}

.attributes dt code, .fields dt code, .dictionary-members dt code {
    background:  #ffffd2;
}

.attributes dt .idlAttrType code, .fields dt .idlFieldType code, .dictionary-members dt .idlMemberType code {
    color:  #005a9c;
    background:  transparent;
    font-family:    inherit;
    font-weight:    normal;
    font-style: italic;
}

.methods dt code {
    background:  #d9e6f8;
}

.constants dt code {
    background:  #ddffd2;
}

.attributes dd, .methods dd, .constants dd, .fields dd, .dictionary-members dd {
    margin-bottom:  1em;
}

table.parameters, table.exceptions {
    border-spacing: 0;
    border-collapse:    collapse;
    margin: 0.5em 0;
    width:  100%;
}
table.parameters { border-bottom:  1px solid #90b8de; }
table.exceptions { border-bottom:  1px solid #deb890; }

.parameters th, .exceptions th {
    color:  #fff;
    padding:    3px 5px;
    text-align: left;
    font-family:    initial;
    font-weight:    normal;
    text-shadow:    #666 1px 1px 0;
}
.parameters th { background: #90b8de; }
.exceptions th { background: #deb890; }

.parameters td, .exceptions td {
    padding:    3px 10px;
    border-top: 1px solid #ddd;
    vertical-align: top;
}

.parameters tr:first-child td, .exceptions tr:first-child td {
    border-top: none;
}

.parameters td.prmName, .exceptions td.excName, .exceptions td.excCodeName {
    width:  100px;
}

.parameters td.prmType {
    width:  120px;
}

table.exceptions table {
    border-spacing: 0;
    border-collapse:    collapse;
    width:  100%;
}

/* --- TOC --- */
.toc a {
    text-decoration:    none;
}

a .secno {
    color:  #000;
}

/* --- TABLE --- */
table.simple {
    border-spacing: 0;
    border-collapse:    collapse;
    border-bottom:  3px solid #005a9c;
}

.simple th {
    background: #005a9c;
    color:  #fff;
    padding:    3px 5px;
    text-align: left;
}

.simple th[scope="row"] {
    background: inherit;
    color:  inherit;
    border-top: 1px solid #ddd;
}

.simple td {
    padding:    3px 10px;
    border-top: 1px solid #ddd;
}

.simple tr:nth-child(even) {
    background: #f0f6ff;
}

/* --- DL --- */
.section dd > p:first-child {
    margin-top: 0;
}

.section dd > p:last-child {
    margin-bottom: 0;
}

.section dd {
    margin-bottom:  1em;
}

.section dl.attrs dd, .section dl.eldef dd {
    margin-bottom:  0;
}

/* --- EXAMPLES --- */
pre.example {
    border-top: 1px solid #ff4500;
    border-bottom: 1px solid #ff4500;
    padding:    1em;
    margin-top: 1em;
}

pre.example::before {
    content:    "Example";
    display:    block;
    width:      150px;
    background: #ff4500;
    color:  #fff;
    font-family:    initial;
    padding:    3px;
    font-weight:    bold;
    margin: -1em 0 1em -1em;
}

/* --- EDITORIAL NOTES --- */
.issue {
    padding:    1em;
    margin: 1em 0em 0em;
    border: 1px solid #f00;
    background: #ffc;
}

.issue::before {
    content:    "Issue";
    display:    block;
    width:  150px;
    margin: -1.5em 0 0.5em 0;
    font-weight:    bold;
    border: 1px solid #f00;
    background: #fff;
    padding:    3px 1em;
}

.note {
    margin: 1em 0em 0em;
    padding:    1em;
    border: 2px solid #cff6d9;
    background: #e2fff0;
}

.note::before {
    content:    "Note";
    display:    block;
    width:  150px;
    margin: -1.5em 0 0.5em 0;
    font-weight:    bold;
    border: 1px solid #cff6d9;
    background: #fff;
    padding:    3px 1em;
}

/* --- Best Practices --- */
div.practice {
    border: solid #bebebe 1px;
    margin: 2em 1em 1em 2em;
}

span.practicelab {
    margin: 1.5em 0.5em 1em 1em;
    font-weight: bold;
    font-style: italic;
}

span.practicelab   { background: #dfffff; }

span.practicelab {
    position: relative;
    padding: 0 0.5em;
    top: -1.5em;
}

p.practicedesc {
    margin: 1.5em 0.5em 1em 1em;
}

@media screen {
    p.practicedesc {
        position: relative;
        top: -2em;
        padding: 0;
        margin: 1.5em 0.5em -1em 1em;
    }
}

/* --- SYNTAX HIGHLIGHTING --- */
pre.sh_sourceCode {
  background-color: white;
  color: black;
  font-style: normal;
  font-weight: normal;
}

pre.sh_sourceCode .sh_keyword { color: #005a9c; font-weight: bold; }           /* language keywords */
pre.sh_sourceCode .sh_type { color: #666; }                            /* basic types */
pre.sh_sourceCode .sh_usertype { color: teal; }                             /* user defined types */
pre.sh_sourceCode .sh_string { color: red; font-family: monospace; }        /* strings and chars */
pre.sh_sourceCode .sh_regexp { color: orange; font-family: monospace; }     /* regular expressions */
pre.sh_sourceCode .sh_specialchar { color: 	#ffc0cb; font-family: monospace; }  /* e.g., \n, \t, \\ */
pre.sh_sourceCode .sh_comment { color: #A52A2A; font-style: italic; }         /* comments */
pre.sh_sourceCode .sh_number { color: purple; }                             /* literal numbers */
pre.sh_sourceCode .sh_preproc { color: #00008B; font-weight: bold; }       /* e.g., #include, import */
pre.sh_sourceCode .sh_symbol { color: blue; }                            /* e.g., *, + */
pre.sh_sourceCode .sh_function { color: black; font-weight: bold; }         /* function calls and declarations */
pre.sh_sourceCode .sh_cbracket { color: red; }                              /* block brackets (e.g., {, }) */
pre.sh_sourceCode .sh_todo { font-weight: bold; background-color: #00FFFF; }   /* TODO and FIXME */

/* Predefined variables and functions (for instance glsl) */
pre.sh_sourceCode .sh_predef_var { color: #00008B; }
pre.sh_sourceCode .sh_predef_func { color: #00008B; font-weight: bold; }

/* for OOP */
pre.sh_sourceCode .sh_classname { color: teal; }

/* line numbers (not yet implemented) */
pre.sh_sourceCode .sh_linenum { display: none; }

/* Internet related */
pre.sh_sourceCode .sh_url { color: blue; text-decoration: underline; font-family: monospace; }

/* for ChangeLog and Log files */
pre.sh_sourceCode .sh_date { color: blue; font-weight: bold; }
pre.sh_sourceCode .sh_time, pre.sh_sourceCode .sh_file { color: #00008B; font-weight: bold; }
pre.sh_sourceCode .sh_ip, pre.sh_sourceCode .sh_name { color: #006400; }

/* for Prolog, Perl... */
pre.sh_sourceCode .sh_variable { color: #006400; }

/* for LaTeX */
pre.sh_sourceCode .sh_italics { color: #006400; font-style: italic; }
pre.sh_sourceCode .sh_bold { color: #006400; font-weight: bold; }
pre.sh_sourceCode .sh_underline { color: #006400; text-decoration: underline; }
pre.sh_sourceCode .sh_fixed { color: green; font-family: monospace; }
pre.sh_sourceCode .sh_argument { color: #006400; }
pre.sh_sourceCode .sh_optionalargument { color: purple; }
pre.sh_sourceCode .sh_math { color: orange; }
pre.sh_sourceCode .sh_bibtex { color: blue; }

/* for diffs */
pre.sh_sourceCode .sh_oldfile { color: orange; }
pre.sh_sourceCode .sh_newfile { color: #006400; }
pre.sh_sourceCode .sh_difflines { color: blue; }

/* for css */
pre.sh_sourceCode .sh_selector { color: purple; }
pre.sh_sourceCode .sh_property { color: blue; }
pre.sh_sourceCode .sh_value { color: #006400; font-style: italic; }

/* other */
pre.sh_sourceCode .sh_section { color: black; font-weight: bold; }
pre.sh_sourceCode .sh_paren { color: red; }
pre.sh_sourceCode .sh_attribute { color: #006400; }

</style><style type="text/css">ol.algorithm { counter-reset:numsection; list-style-type: none; }
ol.algorithm li { margin: 0.5em 0; }
ol.algorithm li:before { font-weight: bold; counter-increment: numsection; content: counters(numsection, ".") ") "; }

</style><link href="http://www.w3.org/StyleSheets/TR/w3c-unofficial" rel="stylesheet" type="text/css" charset="utf-8" /><script type="text/javascript" src="http://s3.amazonaws.com/green-turtle/RDFa.0.14.0.js"></script><meta name="green-turtle-rdfa-message" content="{ &quot;type&quot;: &quot;status&quot;, &quot;loaded&quot;: true, &quot;count&quot;: 194 }" /></head>

<body style="display: inherit; "><div class="head"><p></p><h1 property="dcterms:title" class="title" id="title">The JSON-LD API 1.0</h1><h2 property="bibo:subtitle" id="subtitle">An Application Programming Interface for the JSON-LD Syntax</h2><h2 property="dcterms:issued" datatype="xsd:dateTime" content="2012-05-24T06:33:35+0000" id="unofficial-draft-24-may-2012">Unofficial Draft 24 May 2012</h2><dl><dt>Editors:</dt><dd rel="bibo:editor" inlist=""><span typeof="foaf:Person"><a rel="foaf:homepage" property="foaf:name" content="Manu Sporny" href="http://manu.sporny.org/">Manu Sporny</a>, <a rel="foaf:workplaceHomepage" href="http://digitalbazaar.com/">Digital Bazaar</a></span>
</dd>
<dd rel="bibo:editor" inlist=""><span typeof="foaf:Person"><a rel="foaf:homepage" property="foaf:name" content="Gregg Kellogg" href="http://greggkellogg.net/">Gregg Kellogg</a>, <a rel="foaf:workplaceHomepage" href="http://kellogg-assoc.com/">Kellogg Associates</a></span>
</dd>
<dd rel="bibo:editor" inlist=""><span typeof="foaf:Person"><a rel="foaf:homepage" property="foaf:name" content="Dave Longley" href="http://digitalbazaar.com/">Dave Longley</a>, <a rel="foaf:workplaceHomepage" href="http://digitalbazaar.com/">Digital Bazaar</a></span>
</dd>
<dd rel="bibo:editor" inlist=""><span typeof="foaf:Person"><a rel="foaf:homepage" property="foaf:name" content="Markus Lanthaler" href="http://www.markus-lanthaler.com/">Markus Lanthaler</a>, <a rel="foaf:workplaceHomepage" href="http://www.tugraz.at/">Graz University of Technology</a></span>
</dd>
<dt>Authors:</dt><dd rel="dcterms:contributor"><span typeof="foaf:Person"><a rel="foaf:homepage" property="foaf:name" content="Dave Longley" href="http://digitalbazaar.com/">Dave Longley</a>, <a rel="foaf:workplaceHomepage" href="http://digitalbazaar.com/">Digital Bazaar</a></span>
</dd>
<dd rel="dcterms:contributor"><span typeof="foaf:Person"><a rel="foaf:homepage" property="foaf:name" content="Manu Sporny" href="http://digitalbazaar.com/">Manu Sporny</a>, <a rel="foaf:workplaceHomepage" href="http://digitalbazaar.com/">Digital Bazaar</a></span>
</dd>
<dd rel="dcterms:contributor"><span typeof="foaf:Person"><a rel="foaf:homepage" property="foaf:name" content="Gregg Kellogg" href="http://greggkellogg.net/">Gregg Kellogg</a>, <a rel="foaf:workplaceHomepage" href="http://kellogg-assoc.com/">Kellogg Associates</a></span>
</dd>
<dd rel="dcterms:contributor"><span typeof="foaf:Person"><a rel="foaf:homepage" property="foaf:name" content="Markus Lanthaler" href="http://www.markus-lanthaler.com/">Markus Lanthaler</a>, <a rel="foaf:workplaceHomepage" href="http://www.tugraz.at/">Graz University of Technology</a></span>
</dd>
</dl><p>This document is also available in this non-normative format: <a href="diff-20120426.html">diff to previous version</a>.</p><p class="copyright">This document is licensed under a <a class="subfoot" href="http://creativecommons.org/licenses/by/3.0/" rel="license">Creative Commons Attribution 3.0 License</a>.</p><hr /></div>
<div id="abstract" class="introductory section" property="dcterms:abstract" datatype="" typeof="bibo:Chapter" resource="#abstract" rel="bibo:chapter"><h2>Abstract</h2>
<p>
JSON [<cite><a class="bibref" rel="biblioentry" href="#bib-RFC4627">RFC4627</a></cite>] has proven to be a highly useful object serialization and
messaging format. JSON-LD [<cite><a class="bibref" rel="biblioentry" href="#bib-JSON-LD">JSON-LD</a></cite>] harmonizes the representation of
Linked Data in JSON by outlining a common JSON representation format for
expressing directed graphs; mixing both Linked Data and non-Linked Data in
a single document. This document outlines an Application Programming
Interface and a set of algorithms for programmatically transforming
JSON-LD documents.
</p>
</div><div id="sotd" class="introductory section" typeof="bibo:Chapter" resource="#sotd" rel="bibo:chapter"><h2>Status of This Document</h2><p>This document is merely a public working draft of a potential specification. It has no official standing of any kind and does not represent the support or consensus of any standards organisation.</p>
<p>This document is an experimental work in progress.</p>

<!--  <p>
This document has been reviewed by W3C Members, by software
developers, and by other W3C groups and interested parties, and is
endorsed by the Director as a W3C Recommendation. It is a stable
document and may be used as reference material or cited from another
document. W3C's role in making the Recommendation is to draw attention
to the specification and to promote its widespread deployment. This
enhances the functionality and interoperability of the Web.
</p>  -->

</div><div id="toc" typeof="bibo:Chapter" resource="#toc" rel="bibo:chapter" class="section"><h2 class="introductory">Table of Contents</h2><ul class="toc"><li class="tocline"><a href="#introduction" class="tocxref"><span class="secno">1. </span>Introduction</a><ul class="toc"><li class="tocline"><a href="#how-to-read-this-document" class="tocxref"><span class="secno">1.1 </span>How to Read this Document</a></li><li class="tocline"><a href="#linked-data" class="tocxref"><span class="secno">1.2 </span>Linked Data</a></li><li class="tocline"><a href="#contributing" class="tocxref"><span class="secno">1.3 </span>Contributing</a></li></ul></li><li class="tocline"><a href="#the-application-programming-interface" class="tocxref"><span class="secno">2. </span>The Application Programming Interface</a><ul class="toc"><li class="tocline"><a href="#jsonldprocessor" class="tocxref"><span class="secno">2.1 </span>JsonLdProcessor</a><ul class="toc"><li class="tocline"><a href="#methods" class="tocxref"><span class="secno">2.1.1 </span>Methods</a></li></ul></li><li class="tocline"><a href="#callbacks" class="tocxref"><span class="secno">2.2 </span>Callbacks</a><ul class="toc"><li class="tocline"><a href="#jsonldcallback" class="tocxref"><span class="secno">2.2.1 </span>JsonLdCallback</a><ul class="toc"><li class="tocline"><a href="#methods-1" class="tocxref"><span class="secno">2.2.1.1 </span>Methods</a></li></ul></li><li class="tocline"><a href="#quadcallback" class="tocxref"><span class="secno">2.2.2 </span>QuadCallback</a><ul class="toc"><li class="tocline"><a href="#methods-2" class="tocxref"><span class="secno">2.2.2.1 </span>Methods</a></li></ul></li></ul></li><li class="tocline"><a href="#data-structures" class="tocxref"><span class="secno">2.3 </span>Data Structures</a><ul class="toc"><li class="tocline"><a href="#url" class="tocxref"><span class="secno">2.3.1 </span>URL</a></li><li class="tocline"><a href="#jsonldoptions" class="tocxref"><span class="secno">2.3.2 </span>JsonLdOptions</a></li><li class="tocline"><a href="#quad" class="tocxref"><span class="secno">2.3.3 </span>Quad</a><ul class="toc"><li class="tocline"><a href="#attributes" class="tocxref"><span class="secno">2.3.3.1 </span>Attributes</a></li></ul></li><li class="tocline"><a href="#node" class="tocxref"><span class="secno">2.3.4 </span>Node</a><ul class="toc"><li class="tocline"><a href="#attributes-1" class="tocxref"><span class="secno">2.3.4.1 </span>Attributes</a></li></ul></li><li class="tocline"><a href="#iri" class="tocxref"><span class="secno">2.3.5 </span><abbr title="Internationalized Resource Identifier">IRI</abbr></a><ul class="toc"><li class="tocline"><a href="#attributes-2" class="tocxref"><span class="secno">2.3.5.1 </span>Attributes</a></li></ul></li><li class="tocline"><a href="#blank-node" class="tocxref"><span class="secno">2.3.6 </span>Blank Node</a><ul class="toc"><li class="tocline"><a href="#attributes-3" class="tocxref"><span class="secno">2.3.6.1 </span>Attributes</a></li></ul></li><li class="tocline"><a href="#literal" class="tocxref"><span class="secno">2.3.7 </span>Literal</a><ul class="toc"><li class="tocline"><a href="#attributes-4" class="tocxref"><span class="secno">2.3.7.1 </span>Attributes</a></li></ul></li></ul></li></ul></li><li class="tocline"><a href="#algorithms" class="tocxref"><span class="secno">3. </span>Algorithms</a><ul class="toc"><li class="tocline"><a href="#syntax-tokens-and-keywords" class="tocxref"><span class="secno">3.1 </span>Syntax Tokens and Keywords</a></li><li class="tocline"><a href="#algorithm-terms" class="tocxref"><span class="secno">3.2 </span>Algorithm Terms</a></li><li class="tocline"><a href="#context-processing" class="tocxref"><span class="secno">3.3 </span>Context Processing</a></li><li class="tocline"><a href="#iri-expansion" class="tocxref"><span class="secno">3.4 </span><abbr title="Internationalized Resource Identifier">IRI</abbr> Expansion</a></li><li class="tocline"><a href="#iri-compaction" class="tocxref"><span class="secno">3.5 </span><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction</a><ul class="toc"><li class="tocline"><a href="#iri-compaction-algorithm" class="tocxref"><span class="secno">3.5.1 </span><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction Algorithm</a></li><li class="tocline"><a href="#term-rank-algorithm" class="tocxref"><span class="secno">3.5.2 </span>Term Rank Algorithm</a></li></ul></li><li class="tocline"><a href="#value-expansion" class="tocxref"><span class="secno">3.6 </span>Value Expansion</a></li><li class="tocline"><a href="#value-compaction" class="tocxref"><span class="secno">3.7 </span>Value Compaction</a></li><li class="tocline"><a href="#generate-blank-node-identifier" class="tocxref"><span class="secno">3.8 </span>Generate Blank Node Identifier</a></li><li class="tocline"><a href="#expansion" class="tocxref"><span class="secno">3.9 </span>Expansion</a><ul class="toc"><li class="tocline"><a href="#expansion-algorithm" class="tocxref"><span class="secno">3.9.1 </span>Expansion Algorithm</a></li></ul></li><li class="tocline"><a href="#compaction" class="tocxref"><span class="secno">3.10 </span>Compaction</a><ul class="toc"><li class="tocline"><a href="#compaction-algorithm" class="tocxref"><span class="secno">3.10.1 </span>Compaction Algorithm</a></li></ul></li><li class="tocline"><a href="#framing" class="tocxref"><span class="secno">3.11 </span>Framing</a><ul class="toc"><li class="tocline"><a href="#framing-algorithm-terms" class="tocxref"><span class="secno">3.11.1 </span>Framing Algorithm Terms</a></li><li class="tocline"><a href="#framing-algorithm" class="tocxref"><span class="secno">3.11.2 </span>Framing Algorithm</a></li><li class="tocline"><a href="#subject-map-generation" class="tocxref"><span class="secno">3.11.3 </span>Subject Map Generation</a></li><li class="tocline"><a href="#remove-embed" class="tocxref"><span class="secno">3.11.4 </span>Remove Embedded Definition</a></li><li class="tocline"><a href="#embed-values" class="tocxref"><span class="secno">3.11.5 </span>Embed Values</a></li></ul></li><li class="tocline"><a href="#flattening" class="tocxref"><span class="secno">3.12 </span>Flattening</a><ul class="toc"><li class="tocline"><a href="#flattening-algorithm" class="tocxref"><span class="secno">3.12.1 </span>Flattening Algorithm</a></li></ul></li><li class="tocline"><a href="#rdf-conversion" class="tocxref"><span class="secno">3.13 </span>RDF Conversion</a><ul class="toc"><li class="tocline"><a href="#overview" class="tocxref"><span class="secno">3.13.1 </span>Overview</a></li><li class="tocline"><a href="#rdf-conversion-algorithm-terms" class="tocxref"><span class="secno">3.13.2 </span>RDF Conversion Algorithm Terms</a></li><li class="tocline"><a href="#convert-to-rdf-algorithm" class="tocxref"><span class="secno">3.13.3 </span>Convert to RDF Algorithm</a></li><li class="tocline"><a href="#list-conversion" class="tocxref"><span class="secno">3.13.4 </span>List Conversion</a></li><li class="tocline"><a href="#convert-from-rdf-algorithm" class="tocxref"><span class="secno">3.13.5 </span>Convert from RDF Algorithm</a></li></ul></li></ul></li><li class="tocline"><a href="#data-round-tripping" class="tocxref"><span class="secno">4. </span>Data Round Tripping</a></li><li class="tocline"><a href="#iana-considerations" class="tocxref"><span class="secno">A. </span>IANA Considerations</a></li><li class="tocline"><a href="#appendix-b" class="tocxref"><span class="secno">B. </span>Initial Context</a></li><li class="tocline"><a href="#acknowledgements" class="tocxref"><span class="secno">C. </span>Acknowledgements</a></li><li class="tocline"><a href="#references" class="tocxref"><span class="secno">D. </span>References</a><ul class="toc"><li class="tocline"><a href="#normative-references" class="tocxref"><span class="secno">D.1 </span>Normative references</a></li><li class="tocline"><a href="#informative-references" class="tocxref"><span class="secno">D.2 </span>Informative references</a></li></ul></li></ul></div>



<div id="introduction" typeof="bibo:Chapter" resource="#introduction" rel="bibo:chapter" class="section">

<!-- OddPage -->
<h2><span class="secno">1. </span>Introduction</h2>

<p>
JSON, as specified in [<cite><a class="bibref" rel="biblioentry" href="#bib-RFC4627">RFC4627</a></cite>], is a simple language for representing
data on the Web. Linked Data is a technique for creating a graph of interlinked data across
different
documents or Web sites. Data entities are described using <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>s,
which are typically dereferencable and thus may be used to find more
information about an entity, creating a &quot;Web of Knowledge&quot;. JSON-LD is intended to be a simple
publishing method for expressing not only Linked Data in JSON, but also for adding
semantics to existing JSON.
</p>

<p>
JSON-LD is designed as a light-weight syntax that can be used to express
Linked Data. It is primarily intended to be a way to use Linked Data
in Javascript and other Web-based programming environments. It is also
useful when building interoperable Web services and when storing Linked
Data in JSON-based document storage engines. It is practical and designed
to be as simple as possible, utilizing the large number of JSON parsers
and libraries available today. It is designed to be able to
express key-value pairs, RDF data, RDFa [<cite><a class="bibref" rel="biblioentry" href="#bib-RDFA-CORE">RDFA-CORE</a></cite>] data, Microformats
[<cite><a class="bibref" rel="biblioentry" href="#bib-MICROFORMATS">MICROFORMATS</a></cite>] data, and Microdata [<cite><a class="bibref" rel="biblioentry" href="#bib-MICRODATA">MICRODATA</a></cite>]. That is, it supports
every major Web-based structured data model in use today.
</p>

<p>
The syntax does not necessarily require applications to change their JSON, but
allows to easily add meaning by adding context in a way that is either in-band or
out-of-band. The syntax is designed to not disturb already deployed systems
running on JSON, but provide a smooth upgrade path from JSON to JSON with
added semantics. Finally, the format is intended to be easy to parse, efficient to
generate, convertible to RDF in one pass, and require a very small memory footprint
in order to operate.
</p>

<div id="how-to-read-this-document" typeof="bibo:Chapter" resource="#how-to-read-this-document" rel="bibo:chapter" class="section">
<h3><span class="secno">1.1 </span>How to Read this Document</h3>

<p>
This document is a detailed specification for a serialization of Linked
Data in JSON. The document is primarily intended for the following audiences:
</p>

<ul>
  <li>Authors that want a very detailed view of how JSON-LD processors
  operate.</li>
  <li>Software developers that want to implement processors and APIs for
  JSON-LD.</li>
</ul>

<p>
To understand the basics in this specification you must first be familiar with
JSON, which is detailed in [<cite><a class="bibref" rel="biblioentry" href="#bib-RFC4627">RFC4627</a></cite>]. You must also understand the
JSON-LD Syntax [<cite><a class="bibref" rel="biblioentry" href="#bib-JSON-LD">JSON-LD</a></cite>], which is the base syntax used by all of the
algorithms in this document. To understand the API and how it is
intended to operate  in a programming environment, it is useful to have working
knowledge of the JavaScript programming language [<cite><a class="bibref" rel="biblioentry" href="#bib-ECMA-262">ECMA-262</a></cite>] and
WebIDL [<cite><a class="bibref" rel="biblioentry" href="#bib-WEBIDL">WEBIDL</a></cite>]. To understand how JSON-LD maps to RDF, it is helpful to be
familiar with the basic RDF concepts [<cite><a class="bibref" rel="biblioentry" href="#bib-RDF-CONCEPTS">RDF-CONCEPTS</a></cite>].</p>

<p>
  Examples may contain references to existing vocabularies and use <a class="tref internalDFN" title="prefix" href="#dfn-prefix">prefix</a>es to refer to vocabularies. The following is a list of all vocabularies and their <a class="tref internalDFN" title="prefix" href="#dfn-prefix">prefix</a> abbreviations, as used in this document:
</p>
<ul>
  <li>The <a href="http://purl.org/dc/terms/">Dublin Core</a>
  vocabulary (abbreviation: <code>dc</code>, e.g., <code>dc:title</code>)</li>
  <li>The <a href="http://xmlns.com/foaf/0.1/">Friend of a Friend</a>
  vocabulary (abbreviation: <code>foaf</code>, e.g., <code>foaf:knows</code>)</li>
  <li>The <a href="http://www.w3.org/1999/02/22-rdf-syntax-ns#">RDF</a>
  vocabulary (abbreviation: <code>rdf</code>, e.g., <code>rdf:type</code>)</li>
  <li>The <a href="http://www.w3.org/2001/XMLSchema#">XSD</a>
  vocabulary (abbreviation: <code>xsd</code>, e.g., <code>xsd:integer</code>)</li>
</ul>

<p>
  JSON [<cite><a class="bibref" rel="biblioentry" href="#bib-RFC4627">RFC4627</a></cite>] defines several terms which are used throughout this document:
  </p><dl>
    <dt><dfn title="json_object" id="dfn-json_object">JSON object</dfn></dt><dd>
      An object structure is represented as a pair of curly brackets surrounding zero or
      more name/value pairs. A name is a <a class="tref internalDFN" title="string" href="#dfn-string">string</a>. A single colon comes after
      each name, separating the name from the value. A single comma separates a value
      from a following name. The names within an object <em class="rfc2119" title="should">should</em> be unique.
    </dd>
    <dt><dfn title="array" id="dfn-array">array</dfn></dt>
    <dd>
      An array is an ordered collection of values. An array structure is represented as square brackets surrounding zero or more values (or elements). Elements are separated by commas.  Within JSON-LD, array order is not preserved by default, unless
      specific markup is provided. This is because the basic data model of JSON-LD is a <a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">linked data graph</a>, which is inherently unordered.
    </dd>
    <dt><dfn title="string" id="dfn-string">string</dfn></dt><dd>
      A string is a sequence of zero or more Unicode characters, wrapped in double quotes, using backslash escapes. A
      character is represented as a single character string.
    </dd>
    <dt><dfn title="number" id="dfn-number">number</dfn></dt>
    <dd>
      A number is is similar to that used in most programming languages, except that the octal and hexadecimal formats are not used and that leading zeros are not allowed.</dd>
    <dt><dfn title="true" id="dfn-true">true</dfn> and <dfn title="false" id="dfn-false">false</dfn></dt><dd>
      Boolean values.
    </dd>
    <dt><dfn title="null" id="dfn-null">null</dfn></dt><dd>
      The use of the <a class="tref internalDFN" title="null" href="#dfn-null">null</a> value within JSON-LD is used to ignore or reset values.
    </dd>
    <dt><dfn title="subject_definition" id="dfn-subject_definition">subject definition</dfn></dt><dd>
      A <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> used to represent a <a class="tref internalDFN" title="subject" href="#dfn-subject">subject</a> and one or more properties
      of that subject. A <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> is a subject definition if it does not contain the keys
      <code>@value</code>, <code>@list</code> or <code>@set</code> and it has one or more keys other than <code>@id</code>.</dd>
    <dt><dfn title="subject_reference" id="dfn-subject_reference">subject reference</dfn></dt><dd>
      A <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> used to reference a subject having only the <code>@id</code> key.</dd>
  </dl>
<p></p>
</div>

<div id="linked-data" typeof="bibo:Chapter" resource="#linked-data" rel="bibo:chapter" class="section">
<h3><span class="secno">1.2 </span>Linked Data</h3>
<p>
The following definition for <a class="tref internalDFN" title="linked_data" href="#dfn-linked_data">Linked Data</a> is the one that will
be used for this specification.
</p>
<ol>
  <li><dfn title="linked_data" id="dfn-linked_data">Linked Data</dfn> is a set of documents, each containing a representation of a linked data graph.</li>
  <li>A <dfn title="linked_data_graph" id="dfn-linked_data_graph">linked data graph</dfn> is an unordered labeled directed graph, where nodes are <a class="tref internalDFN" title="subject" href="#dfn-subject">subject</a>s or <a class="tref internalDFN" title="object" href="#dfn-object">object</a>s, and edges are properties.</li>
  <li>A <dfn title="subject" id="dfn-subject">subject</dfn> is any node in a <a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">linked data graph</a> with at least one outgoing edge.</li>
  <li>A <a class="tref internalDFN" title="subject" href="#dfn-subject">subject</a> <em class="rfc2119" title="should">should</em> be labeled with an <dfn title="iri" id="dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></dfn> (an Internationalized Resource Identifier as described in [<cite><a class="bibref" rel="biblioentry" href="#bib-RFC3987">RFC3987</a></cite>]).</li>
  <li>An <dfn title="object" id="dfn-object">object</dfn> is a node in a <a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">linked data graph</a> with at least one incoming edge.</li>
  <li>An <a class="tref internalDFN" title="object" href="#dfn-object">object</a> <em class="rfc2119" title="may">may</em> be labeled with an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>.</li>
  <li>An object <em class="rfc2119" title="may">may</em> be a <a class="tref internalDFN" title="subject" href="#dfn-subject">subject</a> and <a class="tref internalDFN" title="object" href="#dfn-object">object</a> at the same time.</li>
  <li>A <dfn title="property" id="dfn-property">property</dfn> is an edge of the <a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">linked data graph</a>.</li>
  <li>A <a class="tref internalDFN" title="property" href="#dfn-property">property</a> <em class="rfc2119" title="should">should</em> be labeled with an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>.</li>
  <li>An <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a> that is a label in a <a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">linked data graph</a> <em class="rfc2119" title="should">should</em> be dereferencable to a <a class="tref internalDFN" title="linked_data" href="#dfn-linked_data">Linked Data</a> document describing the labeled <a class="tref internalDFN" title="subject" href="#dfn-subject">subject</a>, <a class="tref internalDFN" title="object" href="#dfn-object">object</a> or <a class="tref internalDFN" title="property" href="#dfn-property">property</a>.</li>
  <li>A <dfn title="literal" id="dfn-literal">literal</dfn> is an <a class="tref internalDFN" title="object" href="#dfn-object">object</a> with a label that is not an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a></li>
</ol>

<p>
Note that the definition for <a class="tref internalDFN" title="linked_data" href="#dfn-linked_data">Linked Data</a> above is silent on the
topic of unlabeled nodes. Unlabeled nodes are not considered
<a class="tref internalDFN" title="linked_data" href="#dfn-linked_data">Linked Data</a>. However, this specification allows for the expression
of unlabled nodes, as most graph-based data sets on the Web contain a number
of associated nodes that are not named and thus are not directly
de-referenceable.
</p>
</div>

<div id="contributing" typeof="bibo:Chapter" resource="#contributing" rel="bibo:chapter" class="section">
  <h3><span class="secno">1.3 </span>Contributing</h3>

  <p>There are a number of ways that one may participate in the development of
    this specification:</p>

  <ul>
    <li>Technical discussion typically occurs on the public mailing list:
      <a href="http://lists.w3.org/Archives/Public/public-linked-json/">public-linked-json@w3.org</a></li>

    <li><a href="http://json-ld.org/minutes/">Public teleconferences</a> are held
      on Tuesdays at 1500UTC on the second and fourth week of each month.</li>

    <li>Specification bugs and issues should be reported in the
      <a href="https://github.com/json-ld/json-ld.org/issues">issue tracker</a>.</li>

    <li><a href="https://github.com/json-ld/json-ld.org/tree/main/spec">Source code</a> for the
      specification can be found on Github.</li>

    <li>The <a href="http://webchat.freenode.net/?channels=json-ld">#json-ld</a>
      IRC channel is available for real-time discussion on irc.freenode.net.</li>
  </ul>

</div>

</div>

<div id="the-application-programming-interface" typeof="bibo:Chapter" resource="#the-application-programming-interface" rel="bibo:chapter" class="section">
  
<!-- OddPage -->
<h2><span class="secno">2. </span>The Application Programming Interface</h2>

  <p>This API provides a clean mechanism that enables developers to convert
  JSON-LD data into a a variety of output formats that are easier to work with in
  various programming languages. If a JSON-LD API is provided in a programming
  environment, the entirety of the following API <em class="rfc2119" title="must">must</em> be implemented.
  </p>

  <div id="jsonldprocessor" typeof="bibo:Chapter" resource="#jsonldprocessor" rel="bibo:chapter" class="section">
    <h3><span class="secno">2.1 </span>JsonLdProcessor</h3>
    <pre class="idl"><span class="idlInterface" id="idl-def-JsonLdProcessor">[<span class="extAttr">NoInterfaceObject</span>]
interface <span class="idlInterfaceID">JsonLdProcessor</span> {
<span class="idlMethod">    <span class="idlMethType"><a>void</a></span> <span class="idlMethName"><a href="#widl-JsonLdProcessor-expand-void-object-or-object---or-URL-input-ObjectOrURL-context-JsonLdCallback-callback-JsonLdOptions-options">expand</a></span> (<span class="idlParam"><span class="idlParamType"><a>object or object[] or URL</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam"><span class="idlParamType"><a>ObjectOrURL</a>?</span> <span class="idlParamName">context</span></span>, <span class="idlParam"><span class="idlParamType"><a href="#idl-def-JsonLdCallback" class="idlType"><code>JsonLdCallback</code></a></span> <span class="idlParamName">callback</span></span>, <span class="idlParam">optional <span class="idlParamType"><a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a></span> <span class="idlParamName">options</span></span>);</span>
<span class="idlMethod">    <span class="idlMethType"><a>void</a></span> <span class="idlMethName"><a href="#widl-JsonLdProcessor-compact-void-object-or-object---or-URL-input-object-or-URL-context-JsonLdCallback-callback-JsonLdOptions-options">compact</a></span> (<span class="idlParam"><span class="idlParamType"><a>object or object[] or URL</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam"><span class="idlParamType"><a>object or URL</a></span> <span class="idlParamName">context</span></span>, <span class="idlParam"><span class="idlParamType"><a href="#idl-def-JsonLdCallback" class="idlType"><code>JsonLdCallback</code></a></span> <span class="idlParamName">callback</span></span>, <span class="idlParam">optional <span class="idlParamType"><a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a></span> <span class="idlParamName">options</span></span>);</span>
<span class="idlMethod">    <span class="idlMethType"><a>void</a></span> <span class="idlMethName"><a href="#widl-JsonLdProcessor-frame-void-object-or-object---or-URL-input-object-or-URL-frame-JsonLdCallback-callback-JsonLdOptions-options">frame</a></span> (<span class="idlParam"><span class="idlParamType"><a>object or object[] or URL</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam"><span class="idlParamType"><a>object or URL</a></span> <span class="idlParamName">frame</span></span>, <span class="idlParam"><span class="idlParamType"><a href="#idl-def-JsonLdCallback" class="idlType"><code>JsonLdCallback</code></a></span> <span class="idlParamName">callback</span></span>, <span class="idlParam">optional <span class="idlParamType"><a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a></span> <span class="idlParamName">options</span></span>);</span>
<span class="idlMethod">    <span class="idlMethType"><a>void</a></span> <span class="idlMethName"><a href="#widl-JsonLdProcessor-flatten-void-object-or-object---or-URL-input-string-or-URL-graph-ObjectOrURL-context-JsonLdCallback-callback-JsonLdOptions-options">flatten</a></span> (<span class="idlParam"><span class="idlParamType"><a>object or object[] or URL</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam"><span class="idlParamType"><a>string or URL</a></span> <span class="idlParamName">graph</span></span>, <span class="idlParam"><span class="idlParamType"><a>ObjectOrURL</a>?</span> <span class="idlParamName">context</span></span>, <span class="idlParam"><span class="idlParamType"><a href="#idl-def-JsonLdCallback" class="idlType"><code>JsonLdCallback</code></a></span> <span class="idlParamName">callback</span></span>, <span class="idlParam">optional <span class="idlParamType"><a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a></span> <span class="idlParamName">options</span></span>);</span>
<span class="idlMethod">    <span class="idlMethType"><a>void</a></span> <span class="idlMethName"><a href="#widl-JsonLdProcessor-fromRDF-void-QuadArray-input-JsonLdCallback-callback-JsonLdOptions-options">fromRDF</a></span> (<span class="idlParam"><span class="idlParamType"><a href="#idl-def-Quad" class="idlType"><code>Quad</code></a>[]</span> <span class="idlParamName">input</span></span>, <span class="idlParam"><span class="idlParamType"><a href="#idl-def-JsonLdCallback" class="idlType"><code>JsonLdCallback</code></a></span> <span class="idlParamName">callback</span></span>, <span class="idlParam">optional <span class="idlParamType"><a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a></span> <span class="idlParamName">options</span></span>);</span>
<span class="idlMethod">    <span class="idlMethType"><a>void</a></span> <span class="idlMethName"><a href="#widl-JsonLdProcessor-toRDF-void-object-or-object---or-URL-input-QuadCallback-callback-JsonLdOptions-options">toRDF</a></span> (<span class="idlParam"><span class="idlParamType"><a>object or object[] or URL</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam"><span class="idlParamType"><a href="#idl-def-QuadCallback" class="idlType"><code>QuadCallback</code></a></span> <span class="idlParamName">callback</span></span>, <span class="idlParam">optional <span class="idlParamType"><a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a></span> <span class="idlParamName">options</span></span>);</span>
};</span>
</pre><div id="methods" typeof="bibo:Chapter" resource="#methods" rel="bibo:chapter" class="section"><h4><span class="secno">2.1.1 </span>Methods</h4><dl class="methods"><dt id="widl-JsonLdProcessor-compact-void-object-or-object---or-URL-input-object-or-URL-context-JsonLdCallback-callback-JsonLdOptions-options"><code>compact</code></dt><dd>
        <a href="#compaction">Compacts</a> the given <code>input</code> using the
        <code>context</code> according to the steps in the
        <a href="#compaction-algorithm">Compaction Algorithm</a>. The
        <code>input</code> <em class="rfc2119" title="must">must</em> be copied, compacted and returned if there are
        no errors. If the compaction fails, an appropirate exception <em class="rfc2119" title="must">must</em> be
        thrown.

        

        

        
      <table class="parameters"><tr><th>Parameter</th><th>Type</th><th>Nullable</th><th>Optional</th><th>Description</th></tr><tr><td class="prmName">input</td><td class="prmType"><code><a>object or object[] or URL</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The JSON-LD object or array of JSON-LD objects to perform the compaction upon or an
            <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a> referencing the JSON-LD document to compact.</td></tr><tr><td class="prmName">context</td><td class="prmType"><code><a>object or URL</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The context to use when compacting the <code>input</code>; either in the
            form of an <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> or as <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>.</td></tr><tr><td class="prmName">callback</td><td class="prmType"><code><a href="#idl-def-JsonLdCallback" class="idlType"><code>JsonLdCallback</code></a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">A callback that is called when processing is complete on
            the given <code>input</code>.</td></tr><tr><td class="prmName">options</td><td class="prmType"><code><a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a></code></td><td class="prmNullFalse">✘</td><td class="prmOptTrue">✔</td><td class="prmDesc">A set of options that <em class="rfc2119" title="may">may</em> affect the expansion algorithm such as, e.g., the
            input document's base <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>. This also includes <code>optimize</code>,
            which if set will cause processor-specific optimization.</td></tr></table><div><em>Return type: </em><code><a>void</a></code></div></dd><dt id="widl-JsonLdProcessor-expand-void-object-or-object---or-URL-input-ObjectOrURL-context-JsonLdCallback-callback-JsonLdOptions-options"><code>expand</code></dt><dd>
        <a href="#expansion">Expands</a> the given <code>input</code> according to
        the steps in the <a href="#expansion-algorithm">Expansion Algorithm</a>. The
        <code>input</code> <em class="rfc2119" title="must">must</em> be copied, expanded and returned if there are
        no errors. If the expansion fails, an appropriate exception <em class="rfc2119" title="must">must</em> be thrown.

        

        

        
      <table class="parameters"><tr><th>Parameter</th><th>Type</th><th>Nullable</th><th>Optional</th><th>Description</th></tr><tr><td class="prmName">input</td><td class="prmType"><code><a>object or object[] or URL</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The JSON-LD object or array of JSON-LD objects to perform the expansion upon or an
            <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a> referencing the JSON-LD document to expand.</td></tr><tr><td class="prmName">context</td><td class="prmType"><code><a>ObjectOrURL</a></code></td><td class="prmNullTrue">✔</td><td class="prmOptFalse">✘</td><td class="prmDesc">An optional external context to use additionally to the context embedded in
            <code>input</code> when expanding the <code>input</code>.</td></tr><tr><td class="prmName">callback</td><td class="prmType"><code><a href="#idl-def-JsonLdCallback" class="idlType"><code>JsonLdCallback</code></a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">A callback that is called when processing is complete on
            the given <code>input</code>.</td></tr><tr><td class="prmName">options</td><td class="prmType"><code><a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a></code></td><td class="prmNullFalse">✘</td><td class="prmOptTrue">✔</td><td class="prmDesc">A set of options that <em class="rfc2119" title="may">may</em> affect the expansion algorithm such as, e.g., the
            input document's base <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>.</td></tr></table><div><em>Return type: </em><code><a>void</a></code></div></dd><dt id="widl-JsonLdProcessor-flatten-void-object-or-object---or-URL-input-string-or-URL-graph-ObjectOrURL-context-JsonLdCallback-callback-JsonLdOptions-options"><code>flatten</code></dt><dd>
        <a href="#flattening">Flattens</a> the given <code>input</code> according to
        the steps in the <a href="#flattening-algorithm">Flattening Algorithm</a>. The
        <code>input</code> <em class="rfc2119" title="must">must</em> be flattened and returned if there are
        no errors. If the flattening fails, an appropriate exception <em class="rfc2119" title="must">must</em> be thrown.

        <p class="issue">It is still being discussed if the flatten() method should be
          added or not. See <a href="https://github.com/json-ld/json-ld.org/issues/109">ISSUE-109</a>.</p>

        

        

        
      <table class="parameters"><tr><th>Parameter</th><th>Type</th><th>Nullable</th><th>Optional</th><th>Description</th></tr><tr><td class="prmName">input</td><td class="prmType"><code><a>object or object[] or URL</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The JSON-LD object or array of JSON-LD objects to flatten or an
            <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a> referencing the JSON-LD document to flatten.</td></tr><tr><td class="prmName">graph</td><td class="prmType"><code><a>string or URL</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The graph in the document that should be flattened. To return the default
            graph <code>@default</code> has to be passed, for the merged graph <code>@merged</code>
            and for any other graph the <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a> identifying the graph has to be passed. The
            default value is <code>@merged</code>.</td></tr><tr><td class="prmName">context</td><td class="prmType"><code><a>ObjectOrURL</a></code></td><td class="prmNullTrue">✔</td><td class="prmOptFalse">✘</td><td class="prmDesc">An optional external context to use additionally to the context embedded in
            <code>input</code> when expanding the <code>input</code>.</td></tr><tr><td class="prmName">callback</td><td class="prmType"><code><a href="#idl-def-JsonLdCallback" class="idlType"><code>JsonLdCallback</code></a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">A callback that is called when processing is complete on
            the given <code>input</code>.</td></tr><tr><td class="prmName">options</td><td class="prmType"><code><a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a></code></td><td class="prmNullFalse">✘</td><td class="prmOptTrue">✔</td><td class="prmDesc">A set of options that <em class="rfc2119" title="may">may</em> affect the expansion algorithm such as, e.g., the
            input document's base <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>.</td></tr></table><div><em>Return type: </em><code><a>void</a></code></div></dd><dt id="widl-JsonLdProcessor-frame-void-object-or-object---or-URL-input-object-or-URL-frame-JsonLdCallback-callback-JsonLdOptions-options"><code>frame</code></dt><dd>
        <a href="#framing">Frames</a> the given <code>input</code> using the
        <code>frame</code> according to the steps in the
        <a href="#framing-algorithm">Framing Algorithm</a>. The <code>input</code>
        is used to build the framed output and is returned if there are no errors.
        If there are no matches for the frame, <a class="tref internalDFN" title="null" href="#dfn-null">null</a> <em class="rfc2119" title="must">must</em> be
        returned. Exceptions <em class="rfc2119" title="must">must</em> be thrown if there are errors.

        

        

        
      <table class="parameters"><tr><th>Parameter</th><th>Type</th><th>Nullable</th><th>Optional</th><th>Description</th></tr><tr><td class="prmName">input</td><td class="prmType"><code><a>object or object[] or URL</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The JSON-LD object or array of JSON-LD objects to perform the framing upon or an
            <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a> referencing the JSON-LD document to frame.</td></tr><tr><td class="prmName">frame</td><td class="prmType"><code><a>object or URL</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The frame to use when re-arranging the data of <code>input</code>; either
            in the form of an <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> or as <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>.</td></tr><tr><td class="prmName">callback</td><td class="prmType"><code><a href="#idl-def-JsonLdCallback" class="idlType"><code>JsonLdCallback</code></a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">A callback that is called when processing is complete on
            the given <code>input</code>.</td></tr><tr><td class="prmName">options</td><td class="prmType"><code><a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a></code></td><td class="prmNullFalse">✘</td><td class="prmOptTrue">✔</td><td class="prmDesc">A set of options that <em class="rfc2119" title="may">may</em> affect the framing algorithm such as, e.g., the
            input document's base <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>.</td></tr></table><div><em>Return type: </em><code><a>void</a></code></div></dd><dt id="widl-JsonLdProcessor-fromRDF-void-QuadArray-input-JsonLdCallback-callback-JsonLdOptions-options"><code>fromRDF</code></dt><dd>Creates a JSON-LD document given an set of <a class="datatype idlType" title="quad" href="#idl-def-quad"><code>Quads</code></a>.
        
      <table class="parameters"><tr><th>Parameter</th><th>Type</th><th>Nullable</th><th>Optional</th><th>Description</th></tr><tr><td class="prmName">input</td><td class="prmType"><code><a href="#idl-def-Quad" class="idlType"><code>Quad</code></a>[]</code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">An array of RDF quads.</td></tr><tr><td class="prmName">callback</td><td class="prmType"><code><a href="#idl-def-JsonLdCallback" class="idlType"><code>JsonLdCallback</code></a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">A callback that is called when processing is complete on
            the given <code>input</code>.</td></tr><tr><td class="prmName">options</td><td class="prmType"><code><a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a></code></td><td class="prmNullFalse">✘</td><td class="prmOptTrue">✔</td><td class="prmDesc">A set of options that will affect the algorithm. This includes <code>notType</code>,
            which if set to <a class="tref internalDFN" title="true" href="#dfn-true">true</a> causes the resulting document to use <code>rdf:type</code>
            as a property, instead of <code>@type</code>.</td></tr></table><div><em>Return type: </em><code><a>void</a></code></div></dd><dt id="widl-JsonLdProcessor-toRDF-void-object-or-object---or-URL-input-QuadCallback-callback-JsonLdOptions-options"><code>toRDF</code></dt><dd>
        Processes the <code>input</code> according to the
        <a href="#convert-to-rdf-algorithm">Convert to RDF Algorithm</a>, calling
        the provided <code>callback</code> for each <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a> generated.
        

        

        

      <table class="parameters"><tr><th>Parameter</th><th>Type</th><th>Nullable</th><th>Optional</th><th>Description</th></tr><tr><td class="prmName">input</td><td class="prmType"><code><a>object or object[] or URL</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The JSON-LD object or array of JSON-LD objects to convert to RDF or an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>
            referencing the JSON-LD document to convert to RDF.</td></tr><tr><td class="prmName">callback</td><td class="prmType"><code><a href="#idl-def-QuadCallback" class="idlType"><code>QuadCallback</code></a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">A callback that is called when a <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a> is created from processing
            the given <code>input</code>.
          </td></tr><tr><td class="prmName">options</td><td class="prmType"><code><a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a></code></td><td class="prmNullFalse">✘</td><td class="prmOptTrue">✔</td><td class="prmDesc">A set of options that <em class="rfc2119" title="may">may</em> affect the conversion to RDF such as, e.g.,
            the input document's base <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>.</td></tr></table><div><em>Return type: </em><code><a>void</a></code></div></dd></dl></div>

  </div>

  <div id="callbacks" typeof="bibo:Chapter" resource="#callbacks" rel="bibo:chapter" class="section">
    <h3><span class="secno">2.2 </span>Callbacks</h3>
  <div id="jsonldcallback" typeof="bibo:Chapter" resource="#jsonldcallback" rel="bibo:chapter" class="section">
    <h4><span class="secno">2.2.1 </span>JsonLdCallback</h4>
    <p>The <a href="#idl-def-JsonLdCallback" class="idlType"><code>JsonLdCallback</code></a> is used to return a processed JSON-LD representation
      as the result of processing an API method.</p>

    <pre class="idl"><span class="idlInterface" id="idl-def-JsonLdCallback">[<span class="extAttr">NoInterfaceObject Callback</span>]
interface <span class="idlInterfaceID">JsonLdCallback</span> {
<span class="idlMethod">    <span class="idlMethType"><a>void</a></span> <span class="idlMethName"><a href="#widl-JsonLdCallback-jsonLd-void-ObjectOrObjectArray-jsonld">jsonLd</a></span> (<span class="idlParam"><span class="idlParamType"><a>ObjectOrObjectArray</a></span> <span class="idlParamName">jsonld</span></span>);</span>
};</span>
</pre><div id="methods-1" typeof="bibo:Chapter" resource="#methods-1" rel="bibo:chapter" class="section"><h5><span class="secno">2.2.1.1 </span>Methods</h5><dl class="methods"><dt id="widl-JsonLdCallback-jsonLd-void-ObjectOrObjectArray-jsonld"><code>jsonLd</code></dt><dd>This callback is invoked when processing is complete.
      
      <table class="parameters"><tr><th>Parameter</th><th>Type</th><th>Nullable</th><th>Optional</th><th>Description</th></tr><tr><td class="prmName">jsonld</td><td class="prmType"><code><a>ObjectOrObjectArray</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The processed JSON-LD document.</td></tr></table><div><em>Return type: </em><code><a>void</a></code></div></dd></dl></div>
  </div>
  <div id="quadcallback" typeof="bibo:Chapter" resource="#quadcallback" rel="bibo:chapter" class="section">
    <h4><span class="secno">2.2.2 </span>QuadCallback</h4>
    <p>The <a href="#idl-def-QuadCallback" class="idlType"><code>QuadCallback</code></a> is called whenever the processor generates a
    quad during the <code>quad()</code> call.</p>

    <pre class="idl"><span class="idlInterface" id="idl-def-QuadCallback">[<span class="extAttr">NoInterfaceObject Callback</span>]
interface <span class="idlInterfaceID">QuadCallback</span> {
<span class="idlMethod">    <span class="idlMethType"><a>void</a></span> <span class="idlMethName"><a href="#widl-QuadCallback-quad-void-Quad-quad">quad</a></span> (<span class="idlParam"><span class="idlParamType"><a href="#idl-def-Quad" class="idlType"><code>Quad</code></a></span> <span class="idlParamName">quad</span></span>);</span>
};</span>
</pre><div id="methods-2" typeof="bibo:Chapter" resource="#methods-2" rel="bibo:chapter" class="section"><h5><span class="secno">2.2.2.1 </span>Methods</h5><dl class="methods"><dt id="widl-QuadCallback-quad-void-Quad-quad"><code>quad</code></dt><dd>This callback is invoked whenever a quad is generated by the processor.
      
      <table class="parameters"><tr><th>Parameter</th><th>Type</th><th>Nullable</th><th>Optional</th><th>Description</th></tr><tr><td class="prmName">quad</td><td class="prmType"><code><a href="#idl-def-Quad" class="idlType"><code>Quad</code></a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The quad.</td></tr></table><div><em>Return type: </em><code><a>void</a></code></div></dd></dl></div>
  </div>
  </div>

  <div id="data-structures" typeof="bibo:Chapter" resource="#data-structures" rel="bibo:chapter" class="section">
    <h3><span class="secno">2.3 </span>Data Structures</h3>
    <p>This section describes datatype definitions used within the JSON-LD API.</p>

    <div id="url" typeof="bibo:Chapter" resource="#url" rel="bibo:chapter" class="section">
    <h4><span class="secno">2.3.1 </span>URL</h4>
    <p>The <a href="#idl-def-URL" class="idlType"><code>URL</code></a> datatype is a string representation of an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>.</p>
    <pre class="idl"><span class="idlTypedef" id="idl-def-URL">typedef <span class="idlTypedefType"><a>DOMString</a></span> <span class="idlTypedefID">URL</span>;</span></pre><div class="idlTypedefDesc">
      This datatype indicates that the <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a> is interpreted as a Universal Resource
      Locator
      identifying a document, which when parsed as JSON yields either a <code>JSON object</code>
      or <code>array</code>.
    </div>
    </div>

    <div id="jsonldoptions" typeof="bibo:Chapter" resource="#jsonldoptions" rel="bibo:chapter" class="section">
    <h4><span class="secno">2.3.2 </span>JsonLdOptions</h4>
    <p>The <a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a> type is used to convery a set of options to an interface method.</p>
    <pre class="idl"><span class="idlTypedef" id="idl-def-JsonLdOptions">typedef <span class="idlTypedefType"><a>object</a></span> <span class="idlTypedefID">JsonLdOptions</span>;</span></pre><div class="idlTypedefDesc">
      <dt><a href="#idl-def-URL" class="idlType"><code>URL</code></a> base</dt>
      <dd>The Base <abbr title="Internationalized Resource Identifier">IRI</abbr> to use when expanding the document. This overrides the value of
        <em>input</em> if it is a <a href="#idl-def-URL" class="idlType"><code>URL</code></a> or if it is a <code>object</code> or <code>object[]</code>.</dd>
      <dt>boolean optimize</dt>
      <dd>If set to <code>true</code>, the JSON-LD processor is allowed to
        optimize the output of the <a href="#compaction-algorithm">Compaction Algorithm</a>
        to produce even compacter representations. The algorithm for compaction
        optimization is beyond the scope of this specification and thus
        not defined. Consequently, different implementations <em class="rfc2119" title="may">may</em> implement
        different optimization algorithms.</dd>
      <dt>boolean noType</dt>
      <dd>If set to <code>true</code>, the JSON-LD processor will not use the
        <code>@type</code> property when generating the output, and will use the
        expanded <code>rdf:type</code> <abbr title="Internationalized Resource Identifier">IRI</abbr> as the property instead of <code>@type</code>.</dd>
    </div>
    </div>

    <p>The following data structures are used for representing data about
      RDF quads. They are used for normalization, <a>fromRDF</a>,
      and from <a>toRDF</a> interfaces.
    </p>

    <div id="quad" typeof="bibo:Chapter" resource="#quad" rel="bibo:chapter" class="section">
    <h4><span class="secno">2.3.3 </span>Quad</h4>
    <p>The <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a> interface represents an RDF Quad.
      See [<cite><a class="bibref" rel="biblioentry" href="#bib-RDF-CONCEPTS">RDF-CONCEPTS</a></cite>] definition for
      <cite><a href="http://www.w3.org/TR/rdf11-concepts/#dfn-rdf-triple">RDF triple</a></cite>,
      which most closely aligns to <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a>.
    </p>
    <pre class="idl"><span class="idlInterface" id="idl-def-Quad">[<span class="extAttr">NoInterfaceObject</span>]
interface <span class="idlInterfaceID">Quad</span> {
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span>  <span class="idlAttrName"><a href="#widl-Quad-subject">subject</a></span>;</span>
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span>  <span class="idlAttrName"><a href="#widl-Quad-property">property</a></span>;</span>
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span>  <span class="idlAttrName"><a href="#widl-Quad-object">object</a></span>;</span>
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a href="#idl-def-Node" class="idlType"><code>Node</code></a>?</span> <span class="idlAttrName"><a href="#widl-Quad-name">name</a></span>;</span>
};</span>
</pre><div id="attributes" typeof="bibo:Chapter" resource="#attributes" rel="bibo:chapter" class="section"><h5><span class="secno">2.3.3.1 </span>Attributes</h5><dl class="attributes"><dt id="widl-Quad-name"><code>name</code> of type <span class="idlAttrType"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span>, readonly, nullable</dt><dd>The name associated with the <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a> identifying
        it as a member of a named graph. If the attribute is present,
        it indicates that this quad is a member of a <em>named graph</em>
        associated with <em>name</em>. If it is missing, the quad
        is a member of the <em>default graph</em>.
        <div class="issue">This element is at risk, and may be removed.</div>
      </dd><dt id="widl-Quad-object"><code>object</code> of type <span class="idlAttrType"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span>, readonly</dt><dd>The object associated with the <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a>.</dd><dt id="widl-Quad-property"><code>property</code> of type <span class="idlAttrType"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span>, readonly</dt><dd>The property associated with the <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a>.</dd><dt id="widl-Quad-subject"><code>subject</code> of type <span class="idlAttrType"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span>, readonly</dt><dd>The subject associated with the <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a>.</dd></dl></div>
    </div>

    <div id="node" typeof="bibo:Chapter" resource="#node" rel="bibo:chapter" class="section">
    <h4><span class="secno">2.3.4 </span>Node</h4>
    <p><a href="#idl-def-Node" class="idlType"><code>Node</code></a> is the base class of <a class="datatype idlType" title="IRI" href="#idl-def-IRI"><code><abbr title="Internationalized Resource Identifier">IRI</abbr></code></a>,
    <a href="#idl-def-BlankNode" class="idlType"><code>BlankNode</code></a>, and <a class="datatype idlType" title="Literal" href="#idl-def-Literal"><code>Literal</code></a>.</p>
    <pre class="idl"><span class="idlInterface" id="idl-def-Node">[<span class="extAttr">NoInterfaceObject</span>]
interface <span class="idlInterfaceID">Node</span> {
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a>DOMString</a></span> <span class="idlAttrName"><a href="#widl-Node-nominalValue">nominalValue</a></span>;</span>
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a>DOMString</a></span> <span class="idlAttrName"><a href="#widl-Node-interfaceName">interfaceName</a></span>;</span>
};</span>
</pre><div id="attributes-1" typeof="bibo:Chapter" resource="#attributes-1" rel="bibo:chapter" class="section"><h5><span class="secno">2.3.4.1 </span>Attributes</h5><dl class="attributes"><dt id="widl-Node-interfaceName"><code>interfaceName</code> of type <span class="idlAttrType"><a>DOMString</a></span>, readonly</dt><dd>
        <p>Provides access to the string name of the current interface,
        normally one of <code>&quot;<abbr title="Internationalized Resource Identifier">IRI</abbr>&quot;</code>, <code>&quot;BlankNode&quot;</code> or <code>&quot;Literal&quot;</code>.</p>
        <p>This method serves to disambiguate instances of <a href="#idl-def-Node" class="idlType"><code>Node</code></a> which
        are otherwise identical, such as <a class="datatype idlType" title="IRI" href="#idl-def-IRI"><code><abbr title="Internationalized Resource Identifier">IRI</abbr></code></a> and <a href="#idl-def-BlankNode" class="idlType"><code>BlankNode</code></a>.</p>
      </dd><dt id="widl-Node-nominalValue"><code>nominalValue</code> of type <span class="idlAttrType"><a>DOMString</a></span>, readonly</dt><dd>
        <p>The <code>nominalValue</code> of an <a href="#idl-def-Node" class="idlType"><code>Node</code></a> is refined by
        each interface which extends <a href="#idl-def-Node" class="idlType"><code>Node</code></a>.</p>
      </dd></dl></div>
    </div>

    <div id="iri" typeof="bibo:Chapter" resource="#iri" rel="bibo:chapter" class="section">
    <h4><span class="secno">2.3.5 </span><abbr title="Internationalized Resource Identifier">IRI</abbr></h4>
    <p>A node identified by an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>. IRIs are defined by International
      Resource Identifier [<cite><a class="bibref" rel="biblioentry" href="#bib-IRI">IRI</a></cite>]. See [<cite><a class="bibref" rel="biblioentry" href="#bib-RDF-CONCEPTS">RDF-CONCEPTS</a></cite>] definition for
      <cite><a href="http://www.w3.org/TR/rdf11-concepts/#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a></cite>.</p>
    <pre class="idl"><span class="idlInterface" id="idl-def-IRI">[<span class="extAttr">NoInterfaceObject</span>]
interface <span class="idlInterfaceID">IRI</span> : <span class="idlSuperclass"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span> {
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a>DOMString</a></span> <span class="idlAttrName"><a href="#widl-IRI-nominalValue">nominalValue</a></span>;</span>
};</span>
</pre><div id="attributes-2" typeof="bibo:Chapter" resource="#attributes-2" rel="bibo:chapter" class="section"><h5><span class="secno">2.3.5.1 </span>Attributes</h5><dl class="attributes"><dt id="widl-IRI-nominalValue"><code>nominalValue</code> of type <span class="idlAttrType"><a>DOMString</a></span>, readonly</dt><dd>The <abbr title="Internationalized Resource Identifier">IRI</abbr> identifier of the node.</dd></dl></div>
    </div>

    <div id="blank-node" typeof="bibo:Chapter" resource="#blank-node" rel="bibo:chapter" class="section">
    <h4><span class="secno">2.3.6 </span>Blank Node</h4>

    <p>A <a href="#idl-def-BlankNode" class="idlType"><code>BlankNode</code></a> is a reference to an unnamed resource
      (one for which an <abbr title="Internationalized Resource Identifier">IRI</abbr> may not be known), and may be used in a <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a>
      as a unique reference to that unnamed node. See [<cite><a class="bibref" rel="biblioentry" href="#bib-RDF-CONCEPTS">RDF-CONCEPTS</a></cite>] definition for
      <cite><a href="http://www.w3.org/TR/rdf11-concepts/#dfn-blank-node">blank node</a></cite>.</p>

    <pre class="idl"><span class="idlInterface" id="idl-def-BlankNode">[<span class="extAttr">NoInterfaceObject</span>]
interface <span class="idlInterfaceID">BlankNode</span> : <span class="idlSuperclass"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span> {
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a>DOMString</a></span> <span class="idlAttrName"><a href="#widl-BlankNode-nominalValue">nominalValue</a></span>;</span>
};</span>
</pre><div id="attributes-3" typeof="bibo:Chapter" resource="#attributes-3" rel="bibo:chapter" class="section"><h5><span class="secno">2.3.6.1 </span>Attributes</h5><dl class="attributes"><dt id="widl-BlankNode-nominalValue"><code>nominalValue</code> of type <span class="idlAttrType"><a>DOMString</a></span>, readonly</dt><dd>The temporary identifier of the <a href="#idl-def-BlankNode" class="idlType"><code>BlankNode</code></a>.
        The nominalValue <em class="rfc2119" title="must not">must not</em> be relied upon in any way between two
        separate processing runs of the same document.</dd></dl></div>

    <p class="note">Developers and authors must not assume that the
    nominalValue of a <a href="#idl-def-BlankNode" class="idlType"><code>BlankNode</code></a> will remain the same between two
    processing runs. <a href="#idl-def-BlankNode" class="idlType"><code>BlankNode</code></a> nominalValues are only valid for the
    most recent processing run on the document. <a class="datatype idlType" title="blanknode" href="#idl-def-blanknode"><code>BlankNodes</code></a>
    nominalValues will often be generated differently by different processors.</p>

    <p class="note">Implementers <em class="rfc2119" title="must">must</em> ensure that <a href="#idl-def-BlankNode" class="idlType"><code>BlankNode</code></a> nominalValues are unique
    within the current environment, two <a class="datatype idlType" title="blanknode" href="#idl-def-blanknode"><code>BlankNodes</code></a> are considered equal if, and only if,
    their nominalValues are strictly equal.</p>
    </div>

    <div id="literal" typeof="bibo:Chapter" resource="#literal" rel="bibo:chapter" class="section">
      <h4><span class="secno">2.3.7 </span>Literal</h4>
      <p>Literals represent values such as numbers, dates and strings in
        RDF data. A <a class="datatype idlType" title="Literal" href="#idl-def-Literal"><code>Literal</code></a> is comprised of three attributes:
      </p>

      <ul>
        <li>a lexical representation of the <code>nominalValue</code></li>
        <li>an optional <code>language</code> represented by a string token</li>
        <li>an optional <code>datatype</code> specified by an <a class="datatype idlType" title="IRI" href="#idl-def-IRI"><code><abbr title="Internationalized Resource Identifier">IRI</abbr></code></a></li>
      </ul>

      <p>Literals representing plain text in a natural language may have a
        <code>language</code> attribute specified by a text string token, as specified in
        [<cite><a class="bibref" rel="biblioentry" href="#bib-BCP47">BCP47</a></cite>], normalized to lowercase
        (e.g., <code>'en'</code>, <code>'fr'</code>, <code>'en-gb'</code>).
        They may also have a datatype attribute such as <code>xsd:string</code>.
      </p>

      <p>Literals representing values with a specific datatype, such as
        the integer 72, may have a <code>datatype</code> attribute specified in the form
        of a <a href="#dfn-iri" class="internalDFN"><abbr title="Internationalized Resource Identifier">IRI</abbr></a> (e.g.,
        <code>&lt;http://www.w3.org/2001/XMLSchema#integer&gt;</code>).</p>

      <p> See[<cite><a class="bibref" rel="biblioentry" href="#bib-RDF-CONCEPTS">RDF-CONCEPTS</a></cite>] definition for
      <cite><a href="http://www.w3.org/TR/rdf11-concepts/#dfn-literal">literal</a></cite>.</p>

      <pre class="idl"><span class="idlInterface" id="idl-def-Literal">[<span class="extAttr">NoInterfaceObject</span>]
interface <span class="idlInterfaceID">Literal</span> : <span class="idlSuperclass"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span> {
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a>DOMString</a></span>  <span class="idlAttrName"><a href="#widl-Literal-nominalValue">nominalValue</a></span>;</span>
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a>DOMString</a>?</span> <span class="idlAttrName"><a href="#widl-Literal-language">language</a></span>;</span>
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a href="#idl-def-IRI" class="idlType"><code>IRI</code></a>?</span>       <span class="idlAttrName"><a href="#widl-Literal-datatype">datatype</a></span>;</span>
};</span>
</pre><div id="attributes-4" typeof="bibo:Chapter" resource="#attributes-4" rel="bibo:chapter" class="section"><h5><span class="secno">2.3.7.1 </span>Attributes</h5><dl class="attributes"><dt id="widl-Literal-datatype"><code>datatype</code> of type <span class="idlAttrType"><a href="#idl-def-IRI" class="idlType"><code>IRI</code></a></span>, readonly, nullable</dt><dd>An optional datatype identified by a <abbr title="Internationalized Resource Identifier">IRI</abbr>.</dd><dt id="widl-Literal-language"><code>language</code> of type <span class="idlAttrType"><a>DOMString</a></span>, readonly, nullable</dt><dd>An optional language string as defined in [<cite><a class="bibref" rel="biblioentry" href="#bib-BCP47">BCP47</a></cite>], normalized to lowercase.</dd><dt id="widl-Literal-nominalValue"><code>nominalValue</code> of type <span class="idlAttrType"><a>DOMString</a></span>, readonly</dt><dd>The lexical representation of the Literals value.</dd></dl></div>
    </div>
  </div>

</div>

<div id="algorithms" typeof="bibo:Chapter" resource="#algorithms" rel="bibo:chapter" class="section">

<!-- OddPage -->
<h2><span class="secno">3. </span>Algorithms</h2>

<p>All algorithms described in this section are intended to operate on
language-native data structures. That is, the serialization to a text-based
JSON document isn't required as input or output to any of these algorithms and
language-native data structures <em class="rfc2119" title="must">must</em> be used where applicable.</p>

<div id="syntax-tokens-and-keywords" typeof="bibo:Chapter" resource="#syntax-tokens-and-keywords" rel="bibo:chapter" class="section">
  <h3><span class="secno">3.1 </span>Syntax Tokens and Keywords</h3>

  <p>JSON-LD specifies a number of syntax tokens and <dfn title="keyword" id="dfn-keyword">keyword</dfn>s that are using
  in all algorithms described in this section:</p>

  <dl>
  <dt><code>@context</code></dt><dd>Used to set the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a>.</dd>
  <dt><code>@id</code></dt><dd>Sets the active subject.</dd>
  <dt><code>@language</code></dt><dd>Used to specify the language for a literal.</dd>
  <dt><code>@type</code></dt><dd>Used to set the type of the active subject or the datatype of a literal.</dd>
  <dt><code>@value</code></dt><dd>Used to specify the value of a literal.</dd>
  <dt><code>@container</code></dt><dd>Used to set the container of a particular value.</dd>
  <dt><code>@list</code></dt><dd>Used to express an ordered set of data.</dd>
  <dt><code>@set</code></dt><dd>Used to express an unordered set of data.</dd>
  <dt><code>@graph</code></dt><dd>Used to explicitly express a <a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">linked data graph</a>.</dd>
  <dt><code>:</code></dt><dd>The separator for JSON keys and values that use <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact IRIs</a>.</dd>
  <dt><code>@default</code></dt><dd>Used in <a href="#framing">Framing</a> to set the default value for
    an output property when the framed <a class="tref internalDFN" title="subject_definition" href="#dfn-subject_definition">subject definition</a> does not include such a property.</dd>
  <dt><code>@explicit</code></dt><dd>Used in <a href="#framing">Framing</a> to override the
    value of <a class="tref internalDFN" title="explicit_inclusion_flag" href="#dfn-explicit_inclusion_flag">explicit inclusion flag</a> within a specific frame.</dd>
  <dt><code>@omitDefault</code></dt><dd>Used in <a href="#framing">Framing</a> to override the
    value of <a class="tref internalDFN" title="omit_default_flag" href="#dfn-omit_default_flag">omit default flag</a> within a specific frame.</dd>
  <dt><code>@embed</code></dt><dd>Used in <a href="#framing">Framing</a> to override the
    value of <a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag">object embed flag</a> within a specific frame.</dd>
  <dt><code>@null</code></dt><dd>Used in <a href="#framing">Framing</a> when a value of <a class="tref internalDFN" title="null" href="#dfn-null">null</a>
    should be returned, which would otherwise be removed when <a href="#compaction">Compacting</a>.</dd>
  </dl>

  <p>All JSON-LD tokens and keywords are case-sensitive.</p>
</div>

<div id="algorithm-terms" typeof="bibo:Chapter" resource="#algorithm-terms" rel="bibo:chapter" class="section">
  <h3><span class="secno">3.2 </span>Algorithm Terms</h3>
  <dl>
    <dt><dfn title="initial_context" id="dfn-initial_context">initial context</dfn></dt>
    <dd>
      a context that is specified to the algorithm before processing begins. The contents of the
      initial context is defined in <a href="#appendix-b">Appendix B</a>.
    </dd>
    <dt><dfn title="active_subject" id="dfn-active_subject">active subject</dfn></dt>
    <dd>
      the currently active subject that the processor should use when
      processing.
    </dd>
    <dt><dfn title="active_property" id="dfn-active_property">active property</dfn></dt>
    <dd>
      the currently active property that the processor should use when
      processing. The active property is represented in the original lexical form, which
      is used for finding coercion mappings in the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>.
    </dd>
    <dt><dfn title="active_object" id="dfn-active_object">active object</dfn></dt>
    <dd>
      the currently active object that the processor should use when
      processing.
    </dd>
    <dt><dfn title="active_context" id="dfn-active_context">active context</dfn></dt>
    <dd>
      a context that is used to resolve <a class="tref internalDFN" title="term" href="#dfn-term">term</a>s while the processing
      algorithm is running. The <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> is the context
      contained within the <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a>.
    </dd>
    <dt><dfn title="blank_node" id="dfn-blank_node">blank node</dfn></dt>
    <dd>
      a blank node is a <a class="tref internalDFN" title="resource" href="#dfn-resource">resource</a> which is neither an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a> nor a <a class="tref internalDFN" title="literal" href="#dfn-literal">literal</a>.
      Blank nodes may be named or unnamed and often take on the role of a variable that may represent
      either an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a> or a <a class="tref internalDFN" title="literal" href="#dfn-literal">literal</a>.
    </dd>
    <dt><dfn title="compact_iri" id="dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></dfn></dt>
    <dd>
      a compact <abbr title="Internationalized Resource Identifier">IRI</abbr> is has the form of <a class="tref internalDFN" title="prefix" href="#dfn-prefix">prefix</a> and <em>suffix</em> and is used as a way
      of expressing an <abbr title="Internationalized Resource Identifier">IRI</abbr> without needing to define separate <a class="tref internalDFN" title="term" href="#dfn-term">term</a> definitions for
      each <abbr title="Internationalized Resource Identifier">IRI</abbr> contained within a common vocabulary identified by <a class="tref internalDFN" title="prefix" href="#dfn-prefix">prefix</a>.
    </dd>
    <dt><dfn title="local_context" id="dfn-local_context">local context</dfn></dt>
    <dd>
      a context that is specified within a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a>,
      specified via the <code>@context</code> <a class="tref internalDFN" title="keyword" href="#dfn-keyword">keyword</a>.
    </dd>
    <dt><dfn title="processor_state" id="dfn-processor_state">processor state</dfn></dt>
    <dd>
      the <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a>, which includes the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active
      context</a>, <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>, and
      <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>. The <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a> is managed
      as a stack with elements from the previous <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a>
      copied into a new <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a> when entering a new
      <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a>.
    </dd>
    <dt><dfn title="json-ld_input" id="dfn-json-ld_input">JSON-LD input</dfn></dt>
    <dd>
      The JSON-LD data structure that is provided as input to the algorithm.
    </dd>
    <dt><dfn title="json-ld_output" id="dfn-json-ld_output">JSON-LD output</dfn></dt>
    <dd>
      The JSON-LD data structure that is produced as output by the algorithm.
    </dd>
    <dt><dfn title="term" id="dfn-term">term</dfn></dt><dd>
      A <a class="tref internalDFN" title="term" href="#dfn-term">term</a> is a short word defined in a context that <em class="rfc2119" title="may">may</em> be expanded to an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>
    </dd>
    <dt><dfn title="prefix" id="dfn-prefix">prefix</dfn></dt><dd>
      A <a class="tref internalDFN" title="prefix" href="#dfn-prefix">prefix</a> is a <a class="tref internalDFN" title="term" href="#dfn-term">term</a> that expands to a vocabulary base <abbr title="Internationalized Resource Identifier">IRI</abbr>. It
      is typically used along with a <em>suffix</em> to form a <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a> to create an <abbr title="Internationalized Resource Identifier">IRI</abbr>
      within a vocabulary.
    </dd>
    <dt><dfn title="plain_literal" id="dfn-plain_literal">plain literal</dfn></dt><dd>
      A <a class="tref internalDFN" title="plain_literal" href="#dfn-plain_literal">plain literal</a> is a <a class="tref internalDFN" title="literal" href="#dfn-literal">literal</a> without a datatype, possibly including
      a language.
    </dd>
    <dt><dfn title="typed_literal" id="dfn-typed_literal">typed literal</dfn></dt><dd>
      A <a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">typed literal</a> is a <a class="tref internalDFN" title="literal" href="#dfn-literal">literal</a> with an associated <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>
      which indicates the literal's datatype.
    </dd>
  </dl>
</div>

<div id="context-processing" typeof="bibo:Chapter" resource="#context-processing" rel="bibo:chapter" class="section">
  <h3 id="context"><span class="secno">3.3 </span>Context Processing</h3>
  <p>Processing of JSON-LD data structure is managed recursively.
    During processing, each rule is applied using information provided by the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>.
    Processing begins by pushing a new <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a> onto the <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a> stack and
    initializing the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> with the <a class="tref internalDFN" title="initial_context" href="#dfn-initial_context">initial context</a>.
    If a <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a> is encountered,
    information from the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a> is merged into the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>.</p>
  <p>The <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> is used for expanding properties and values of a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> (or elements
    of an array) using a <dfn title="term_mapping" id="dfn-term_mapping">term mapping</dfn>. It is also used to maintain
    <dfn title="coercion_mapping" id="dfn-coercion_mapping">coercion mapping</dfn>s from terms to datatypes, <dfn title="language_mapping" id="dfn-language_mapping">language mapping</dfn>s from terms to language codes,
    and <dfn title="list_mapping" id="dfn-list_mapping">list mapping</dfn>s and <dfn title="set_mapping" id="dfn-set_mapping">set mapping</dfn>s for terms. Processors <em class="rfc2119" title="must">must</em> use the
    lexical form of the property when creating a mapping, as lookup is performed on lexical representations, not
    expanded <abbr title="Internationalized Resource Identifier">IRI</abbr> representations.</p>
  <p>A <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a> is identified within a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> having a <code>@context</code>
    property with a <a class="tref internalDFN" title="string" href="#dfn-string">string</a>, <a class="tref internalDFN" title="array" href="#dfn-array">array</a> or a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> value.
    When processing a <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a>, special processing rules apply:</p>
  <ol class="algorithm">
    <li>Create a new, empty <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a>.</li>
    <li>Let <em>context</em> be the value of <code>@context</code>
      <ol class="algorithm">
        <li id="process-context">If <em>context</em> equals <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, reset the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>
          to the <a class="tref internalDFN" title="initial_context" href="#dfn-initial_context">initial context</a>.</li>
        <li>If <em>context</em> is an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, process each element as <em>context</em> in order
          by starting at <a href="#process-context">Step 2.1</a>.</li>
        <li>If <em>context</em> is a <a class="tref internalDFN" title="string" href="#dfn-string">string</a>, it <em class="rfc2119" title="must">must</em> have a lexical form of <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a>.
          <ol class="algorithm">
            <li>Dereference <em>context</em>.</li>
            <li>If the resulting document is a JSON document, extract the top-level <code>@context</code>
              element using the JSON Pointer &quot;/@context&quot; as described in [<cite><a class="bibref" rel="biblioentry" href="#bib-JSON-POINTER">JSON-POINTER</a></cite>]. Set <em>context</em>
              to the extracted content and process it by starting at <a href="#process-context">Step 2.1</a>.</li>
          </ol>
        </li>
        <li>If <em>context</em> is a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a>, perform the following steps:
          <ol class="algorithm">
            <li>If <em>context</em> has a <code>@language</code> property, it <em class="rfc2119" title="must">must</em> have a value of a
              simple <a class="tref internalDFN" title="string" href="#dfn-string">string</a> or <a class="tref internalDFN" title="null" href="#dfn-null">null</a>. Add the language to the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a>.</li>
            <li id="object-context">Otherwise, for each property in <em>context</em> perform the following steps:
              <ol class="algorithm">
                <li>If the property's value is a simple <a class="tref internalDFN" title="string" href="#dfn-string">string</a>, determine the <abbr title="Internationalized Resource Identifier">IRI</abbr> mapping value by
                  performing <a href="#iri-expansion"><abbr title="Internationalized Resource Identifier">IRI</abbr> Expansion</a> on the associated value. If the result of the <abbr title="Internationalized Resource Identifier">IRI</abbr>
                  mapping is an <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a>, merge the property into the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a>
                  <a class="tref internalDFN" title="term_mapping" href="#dfn-term_mapping">term mapping</a>, unless the property is a JSON-LD <a class="tref internalDFN" title="keyword" href="#dfn-keyword">keyword</a>, in which
                  case throw an exception.</li>
                <li>Otherwise, if the property's value is <a class="tref internalDFN" title="null" href="#dfn-null">null</a> remove mapping, coercion,
                  container and language information associated with property from the
                  <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a>.</li>
                <li>Otherwise, the <em>property</em>'s <em>value</em> <em class="rfc2119" title="must">must</em> be a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a>.
                  <ol class="algorithm">
                    <li>If the <em>property</em> is a JSON-LD <a class="tref internalDFN" title="keyword" href="#dfn-keyword">keyword</a> and the value has
                      <code>@id</code>, <code>@language</code> or <code>@type</code> properties, throw an exception.
                      <div class="issue">Undecided if <code>@type</code> or <code>@graph</code> can take a
                        <code>@container</code> with <code>@set</code>.
                      </div>
                    </li>
                    <li>If the <em>property</em> has the form of <a class="tref internalDFN" title="term" href="#dfn-term">term</a>, its <em>value</em> <em class="rfc2119" title="must">must</em> have an
                      <code>@id</code> property with a string value which <em class="rfc2119" title="must">must</em> have the form of a <a class="tref internalDFN" title="term" href="#dfn-term">term</a>,
                      <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a>, or <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a>. Determine the <abbr title="Internationalized Resource Identifier">IRI</abbr> mapping
                      by performing <a href="#iri-expansion"><abbr title="Internationalized Resource Identifier">IRI</abbr> Expansion</a> on the associated value.
                      If the result of the <abbr title="Internationalized Resource Identifier">IRI</abbr> mapping is an <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a>, merge the
                      <em>property</em> into the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a> <a class="tref internalDFN" title="term_mapping" href="#dfn-term_mapping">term mapping</a>.</li>
                    <li>If the <em>property</em> has the form of of a <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a> or <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a>,
                      the <em>value</em> <em class="rfc2119" title="may">may</em> have a <code>@id</code> property with a string value which <em class="rfc2119" title="must">must</em> have the
                      form of a <a class="tref internalDFN" title="term" href="#dfn-term">term</a>, <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a>, or absolute <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>.
                      Determine the <abbr title="Internationalized Resource Identifier">IRI</abbr> mapping by performing <a href="#iri-expansion"><abbr title="Internationalized Resource Identifier">IRI</abbr> Expansion</a> on the associated
                      value. If the result of the <abbr title="Internationalized Resource Identifier">IRI</abbr> mapping is an <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a>, merge the
                      <em>property</em> into the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a> <a class="tref internalDFN" title="term_mapping" href="#dfn-term_mapping">term mapping</a>.</li>
                    <li>If the <em>value</em> has a <code>@type</code> property, its value <em class="rfc2119" title="must">must</em> have the form of a <a class="tref internalDFN" title="term" href="#dfn-term">term</a>,
                      <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a>, <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a>, or the <a class="tref internalDFN" title="keyword" href="#dfn-keyword">keyword</a> <code>@id</code>.
                      Determine the <abbr title="Internationalized Resource Identifier">IRI</abbr> by performing <a href="#iri-expansion"><abbr title="Internationalized Resource Identifier">IRI</abbr> Expansion</a> on the associated value.
                      If the result of the <abbr title="Internationalized Resource Identifier">IRI</abbr> mapping is an <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a> or <code>@id</code>, merge into the
                      <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a> <a class="tref internalDFN" title="coercion_mapping" href="#dfn-coercion_mapping">coercion mapping</a> using the lexical value of the <em>property</em>.</li>
                    <li>If the <em>value</em> has a <code>@container</code> property, its value <em class="rfc2119" title="must">must</em> be <code>@list</code> or
                      <code>@set</code>. Merge the <a class="tref internalDFN" title="list_mapping" href="#dfn-list_mapping">list mapping</a> or <a class="tref internalDFN" title="set_mapping" href="#dfn-set_mapping">set mapping</a> into the
                      <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a> using the lexical value of the <em>property</em>.</li>
                    <li>If the <em>value</em> has a <code>@language</code> property but no <code>@type</code> property, the value of the
                      <code>@language</code> property <em class="rfc2119" title="must">must</em> be a <a class="tref internalDFN" title="string" href="#dfn-string">string</a> or <a class="tref internalDFN" title="null" href="#dfn-null">null</a>.
                      Merge the <a class="tref internalDFN" title="language_mapping" href="#dfn-language_mapping">language mapping</a> into the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a> using the lexical value of the
                      <em>property</em>.</li>
                  </ol>
                </li>
                <li>Merge the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a> into the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>.</li>
                <li>Repeat <a href="#object-context">Step 2.4.2</a> until no entries are added to the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local
                  context</a>.</li>
              </ol>
            </li>
          </ol>
        </li>
      </ol>
    </li>
  </ol>

  <p class="note">It can be difficult to distinguish between a <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a> and an <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a>,
    as a <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a> may seem to be a valid <abbr title="Internationalized Resource Identifier">IRI</abbr> <em>scheme</em>. When performing repeated <abbr title="Internationalized Resource Identifier">IRI</abbr> expansion,
    a term used as a prefix may not have a valid mapping due to dependencies in resolving term definitions. By
    continuing <a href="#object-context">Step 2.3.2</a> until no changes are made, mappings to IRIs created
    using an undefined term prefix will eventually resolve to <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a>s.</p>

  <p class="issue"><a href="https://github.com/json-ld/json-ld.org/issues/43">Issue 43</a>
    concerns performing <abbr title="Internationalized Resource Identifier">IRI</abbr> expansion in the key position of a context definition.</p>
</div>

<div id="iri-expansion" typeof="bibo:Chapter" resource="#iri-expansion" rel="bibo:chapter" class="section">
  <h3><span class="secno">3.4 </span><abbr title="Internationalized Resource Identifier">IRI</abbr> Expansion</h3>
  <p>Keys and some values are evaluated to produce an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>. This section defines an algorithm for
    transforming a value representing an <abbr title="Internationalized Resource Identifier">IRI</abbr> into an actual <abbr title="Internationalized Resource Identifier">IRI</abbr>.</p>
  <p><a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>s may be represented as an <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a>, a <a class="tref internalDFN" title="term" href="#dfn-term">term</a> or a <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a>.</p>
  <p>An <dfn title="absolute_iri" id="dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></dfn> is defined in [<cite><a class="bibref" rel="biblioentry" href="#bib-RFC3987">RFC3987</a></cite>] containing a <em>scheme</em> along with
    <em>path</em> and optional <em>query</em> and fragment segments. A <dfn title="relative_iri" id="dfn-relative_iri">relative <abbr title="Internationalized Resource Identifier">IRI</abbr></dfn> is an <abbr title="Internationalized Resource Identifier">IRI</abbr>
    that is relative some other <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a>; in the case of JSON-LD this is the base location
    of the document.</p>

  <p>The algorithm for generating an <abbr title="Internationalized Resource Identifier">IRI</abbr> is:
    </p><ol class="algorithm">
      <li>If the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> contains a <a class="tref internalDFN" title="term" href="#dfn-term">term</a> mapping for the value using
        a case-sensitive comparison, use the mapped value as an <abbr title="Internationalized Resource Identifier">IRI</abbr>.</li>
      <li>Otherwise, split the value into a <em>prefix</em> and <em>suffix</em> from the first occurrence of ':'.</li>
      <li>If the prefix is a '_' (underscore), the value represents a named <a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">blank node</a>.</li>
      <li>If the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> contains a <a class="tref internalDFN" title="term" href="#dfn-term">term</a> mapping for <em>prefix</em> using
        a case-sensitive comparison, and <em>suffix</em> does not does not begin with '//'
        (i.e., it does not match a <em>hier-part</em> including
        <em>authority</em> (as defined in [<cite><a class="bibref" rel="biblioentry" href="#bib-RFC3986">RFC3986</a></cite>]), generate an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>
        by prepending the mapped prefix to the (possibly empty) suffix using textual concatenation. Note that an empty
        suffix and no suffix (meaning the value contains no ':' string at all) are treated equivalently.</li>
      <li>Otherwise, use the value directly as an <abbr title="Internationalized Resource Identifier">IRI</abbr>.</li>
    </ol>
  <p></p>
  <p class="note">
    Previous versions of this specification used <code>@base</code> and <code>@vocab</code> to define <abbr title="Internationalized Resource Identifier">IRI</abbr> prefixes
    used to resolve <a class="tref internalDFN" title="relative_iri" href="#dfn-relative_iri">relative IRIs</a>. It was determined that this added too much complexity, but the issue
    can be re-examined in the future based on community input.
  </p>
</div>

<div id="iri-compaction" typeof="bibo:Chapter" resource="#iri-compaction" rel="bibo:chapter" class="section">
  <h3><span class="secno">3.5 </span><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction</h3>
  <p>Some keys and values are expressed using <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>s. This section defines an
    algorithm for transforming an <abbr title="Internationalized Resource Identifier">IRI</abbr> (<em>iri</em>) to a <a class="tref internalDFN" title="term" href="#dfn-term">term</a> or <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a> using the
    <a class="tref internalDFN" title="term" href="#dfn-term">term</a>s specified in the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> using an optional <em>value</em>.</p>

<div id="iri-compaction-algorithm" typeof="bibo:Chapter" resource="#iri-compaction-algorithm" rel="bibo:chapter" class="section">
  <h4><span class="secno">3.5.1 </span><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction Algorithm</h4>
  <p>The algorithm for generating a <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a> is:
    </p><ol class="algorithm">
      <li>Create an empty list of terms <em>terms</em> that will be populated with
        <a class="tref internalDFN" title="term" href="#dfn-term">term</a>s that are ranked according to how closely they match
        <em>value</em>. Initialize <em>highest rank</em> to <code>0</code>,
        and set a flag <em>list container</em> to <code>false</code>.</li>
      <li>For each <em>term</em> in the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>:
        <ol class="algorithm">
          <li>If the <em>term</em>'s <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a> is not a complete match against
            <em>iri</em>, continue to the next <em>term</em>.</li>
          <li>If <em>value</em> is a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> containing only the property <code>@list</code>:
            <ol class="algorithm">
              <li>If <em>term</em> has a <code>@container</code> set to <code>@set</code>, continue
                to the next <em>term</em>.</li>
              <li>If <em>list container</em> is <code>true</code> and <em>term</em> does not have a
                <code>container</code> set to <code>@list</code>, continue to the next <em>term</em>.</li>
            </ol>
          </li>
          <li>Otherwise, if <em>term</em> has a <code>container</code> set to <code>@list</code>,
            continue to the next <em>term</em>.</li>
          <li>Set <em>rank</em> to the <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a> of <em>value</em> by passing
            passing <em>term</em>, <em>value</em>, and <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> to
            the <a href="#term-rank-algorithm">Term Rank Algorithm</a>.</li>
          <li>If <em>rank</em> is greater than <code>0</code>:
            <ol class="algorithm">
              <li>If <em>term</em> has a <code>container</code> set to <code>@set</code>, then add
                <code>1</code> to <em>rank</em>.</li>
              <li>If <em>value</em> is a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> containing only the property <code>@list</code>
                and <em>list container</em> is <code>false</code> and <em>term</em> has a <code>container</code>
                set to <code>@list</code>, then set <em>list container</em> to <code>true</code>, clear
                <em>terms</em>, set <em>highest rank</em> to <em>rank</em>, and add <em>term</em> to <em>terms</em>.</li>
              <li>Otherwise, if <em>rank</em> is greater than or equal to <em>highest rank</em>:
                <ol class="algorithm">
                  <li>If <em>rank</em> is greater than <em>highest rank</em>, clear <em>terms</em> and set
                    <em>highest rank</em> to <em>rank</em>.</li>
                  <li>Add <em>term</em> to <em>terms</em>.</li>
                </ol>
              </li>
            </ol>
          </li>
        </ol>
      </li>
      <li>If <em>terms</em> is empty, add a <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a> representation of <em>iri</em>
        for each <a class="tref internalDFN" title="term" href="#dfn-term">term</a> in the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> which
        maps to an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a> which is a prefix for <em>iri</em> where
        the resulting <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a> is not a <a class="tref internalDFN" title="term" href="#dfn-term">term</a> in the
        <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>. The resulting <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a> is the
        <a class="tref internalDFN" title="term" href="#dfn-term">term</a> associated with the partially
        matched <abbr title="Internationalized Resource Identifier">IRI</abbr> in the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> concatenated with a
        colon (:) character and the unmatched part of <em>iri</em>.</li>
      <li>If <em>terms</em> is empty, return <em>iri</em>.</li>
      <li>Otherwise, return the shortest and lexicographically least value in <em>terms</em>.</li>
    </ol>
  <p></p>
</div>

<div id="term-rank-algorithm" typeof="bibo:Chapter" resource="#term-rank-algorithm" rel="bibo:chapter" class="section">
<h4><span class="secno">3.5.2 </span>Term Rank Algorithm</h4>
<p>When selecting among multiple possible terms for a given property, it may be that multiple
  <a class="tref internalDFN" title="term" href="#dfn-term">terms</a> are defined with the same <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>, but differ in <code>@type</code>, <code>@container</code>
  or <code>@language</code>. The purpose of this algorithm is to take a <a class="tref internalDFN" title="term" href="#dfn-term">term</a>
  and a value and give it a <dfn title="term_rank" id="dfn-term_rank">term rank</dfn>. The selection can then be based, partly, on
  the term having the highest <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a>.</p>
<p>Given a <a class="tref internalDFN" title="term" href="#dfn-term">term</a> <em>term</em>, <em>value</em>, and <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>
  determine the <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a> using the following steps:</p>
<ol class="algorithm">
  <li>If <em>value</em> is <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a> is <code>3</code>.</li>
  <li>Otherwise, if <em>value</em> is a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> containing only the property <code>@list</code>:
    <ol class="algorithm">
      <li>If the <code>@list</code> property is an empty array, if <em>term</em> has <code>@container</code>
        set to <code>@list</code>, <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a> is <code>1</code>, otherwise <code>0</code>.</li>
      <li>Otherwise, return the sum of the <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a>s for every entry in the list.</li>
    </ol>
  </li>
  <li>Otherwise, <em>value</em> <em class="rfc2119" title="must">must</em> be a <a class="tref internalDFN" title="subject_definition" href="#dfn-subject_definition">subject definition</a>, <a class="tref internalDFN" title="subject_reference" href="#dfn-subject_reference">subject reference</a>,
    or a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> having a <code>@value</code>.
    <ol class="algorithm">
      <li>If <em>value</em> has a <code>@value</code> property:
        <ol class="algorithm">
          <li>If <em>value</em> has a <code>@type</code> property matching a
            <code>@type</code> coercion for <em>term</em>, <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a>
            is <code>3</code>, otherwise if <em>term</em> has no <code>@type</code>
            coercion and no <code>@language</code>, <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a> is
            <code>1</code>, otherwise <code>0</code>.</li>
          <li>Otherwise, if <code>@value</code> is not a <a class="tref internalDFN" title="string" href="#dfn-string">string</a>, if <em>term</em> has
            no <code>@type</code> or <code>@language</code> it is <code>2</code>, otherwise <code>1</code>.</li>
          <li>Otherwise, if <em>value</em> has no <code>@language</code> property, if <em>term</em> has
            <code>@language</code> <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, or <em>term</em> has no <code>@type</code> or
            <code>@language</code> and the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> has no <code>@language</code>,
            <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a> is <code>3</code>, otherwise <code>0</code>.</li>
          <li>Otherwise, if <em>value</em> has a <code>@language</code> property matching a
            <code>@language</code> definition for <em>term</em> (or
            <em>term</em> has no <code>@type</code> or <code>@language</code> definition and
            <code>@language</code> in the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> matches the
            <em>value</em> <code>@language</code>), <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a> is
            <code>3</code>, otherwise if <em>term</em> has no <code>@type</code>
            coercion and no <code>@language</code>, <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a> is
            <code>1</code>, otherwise <code>0</code>.</li>
        </ol>
      </li>
      <li>Otherwise, if <em>term</em> has <code>@type</code> coerced to <code>@id</code>,
        <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a> is <code>3</code>, otherwise
        if <em>term</em> has no <code>@type</code> coercion and no <code>@language</code>,
        <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a> is <code>1</code>, otherwise <code>0</code>.</li>
    </ol>
  </li>
  <li>Return <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a>.</li>
</ol>
</div>

</div>

<div id="value-expansion" typeof="bibo:Chapter" resource="#value-expansion" rel="bibo:chapter" class="section">
  <h3><span class="secno">3.6 </span>Value Expansion</h3>
  <p>Some values in JSON-LD can be expressed in a compact form. These values
    are required to be expanded at times when processing JSON-LD documents.</p>

  <p>The algorithm for expanding a <em>value</em> takes an <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>
    and <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>. It is implemented as follows:</p>
  <ol class="algorithm">
    <li>If <em>value</em> is <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, the <em>value</em> is already expanded.</li>
    <li>If <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> is <code>@graph</code> or the target of an <code>@id</code> coercion,
      expand the value into an object with a key-value pair where the key is <code>@id</code> and the value is
      the expanded <abbr title="Internationalized Resource Identifier">IRI</abbr> according to the <a href="#iri-expansion"><abbr title="Internationalized Resource Identifier">IRI</abbr> Expansion</a> rules.</li>
    <li>Otherwise, if <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> is not a <a class="tref internalDFN" title="keyword" href="#dfn-keyword">keyword</a>, then expand <em>value</em> into an
      object:
      <ol class="algorithm">
        <li>Set the first key-value pair to <code>@value</code> and the unexpanded <em>value</em>.</li>
        <li>If the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> is the target of typed literal coercion, set the second key-value pair
          to <code>@type</code> and the associated coercion datatype expanded according to the
          <a href="#iri-expansion"><abbr title="Internationalized Resource Identifier">IRI</abbr> Expansion</a> rules.</li>
        <li>Otherwise, if the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> is the target of language tagging, set the second key-value
          pair to <code>@language</code> and value of the language tagging from the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>.</li>
      </ol>
    </li>
    <li>Otherwise, <em>value</em> is already expanded.</li>
  </ol>
</div>

<div id="value-compaction" typeof="bibo:Chapter" resource="#value-compaction" rel="bibo:chapter" class="section">
  <h3><span class="secno">3.7 </span>Value Compaction</h3>
  <p>Some values, such as <a class="tref internalDFN" title="iri" href="#dfn-iri">IRIs</a> and <a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">typed literals</a>, may be expressed in an
    expanded form in JSON-LD. These values are required to be compacted at
    times when processing JSON-LD documents.
  </p>

  <p>The algorithm for compacting an expanded value <em>value</em> takes an <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>
    and <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>. It is implemented as follows:</p>
  <ol class="algorithm">
    <li>If <em>value</em> only has one property, then the compacted value is the value
      of <code>@value</code>.</li>
    <li>Otherwise, if <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> is <code>@graph</code>, the compacted value is the
      value associated with the <code>@id</code> key, processed according to
      the <a href="#iri-compaction"><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction</a> steps.</li>
    <li>Otherwise, if the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> contains a coercion target for the
      key that matches the expression of the value, compact the value using the
      following steps:
      <ol class="algorithm">
        <li>If the coercion target is an <code>@id</code>, the compacted
          value is the value associated with the <code>@id</code> key,
          processed according to the
          <a href="#iri-compaction"><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction</a> steps.</li>
        <li>If the coercion target is a <a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">typed literal</a>, the compacted
          value is the value associated with the <code>@value</code> key.</li>
      </ol>
    </li>
    <li>Otherwise, if <em>value</em> contains an <code>@id</code> key, the compacted value is <em>value</em> with
      the value of <code>@id</code> processed according to the
      <a href="#iri-compaction"><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction</a> steps.</li>
    <li>Otherwise, if the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> contains a <code>@language</code>, which
      matches the <code>@language</code> of the value, or the value has only a <code>@value</code> key, the compacted
      value is the value associated with the <code>@value</code> key.</li>
    <li>Otherwise, if the value contains a <code>@type</code> key, the compacted value
      is <em>value</em> with the <code>@type</code> value processed according to the
      <a href="#iri-compaction"><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction</a> steps.</li>
    <li>Otherwise, the value is not modified.</li>
  </ol>
</div>

<div id="generate-blank-node-identifier" typeof="bibo:Chapter" resource="#generate-blank-node-identifier" rel="bibo:chapter" class="section">
<h3><span class="secno">3.8 </span>Generate Blank Node Identifier</h3>
<p>This algorithm is used by the <a href="#framing-algorithm">Framing Algorithm</a> and
  <a href="#convert-from-rdf-algorithm">Convert From RDF Algorithm</a> to deterministicly name
  <a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">blank node</a> identifiers. It uses a <em>identifier map</em> and <em>prefix</em>
  and takes a possibly <a class="tref internalDFN" title="null" href="#dfn-null">null</a> identifier and returns a new identifier based on <em>prefix</em>.</p>
<p>The variable <em>next identifier</em> is initialized to <em>prefix</em> appended with <code>0</code>.</p>

<ol class="algorithm">
  <li>If the old identifier is not null and is in <em>identifier map</em> return the mapped identifier.</li>
  <li>Otherwise, if old identifier is not null, create a new entry in <em>identifier map</em> initialized
    to the current value of <em>next identifier</em>. Increment <em>next identifier</em> by adding one
    to the integer suffix. Return the mapped identifier.</li>
  <li>Otherwise, increment <em>next identifier</em> by adding one to the integer suffix and return its
    original value.</li>
</ol>
</div>

<div id="expansion" typeof="bibo:Chapter" resource="#expansion" rel="bibo:chapter" class="section">
<h3><span class="secno">3.9 </span>Expansion</h3>

<p>Expansion is the process of taking a JSON-LD document and applying a
  context such that all <abbr title="Internationalized Resource Identifier">IRI</abbr>, datatypes, and literal values are expanded so
  that the context is no longer necessary. JSON-LD document expansion
  is typically used as a part of <a href="#framing">Framing</a>.</p>

<p>For example, assume the following JSON-LD input document:</p>

<pre class="example">{
   &quot;@context&quot;:
   {
      &quot;name&quot;: &quot;http://xmlns.com/foaf/0.1/name&quot;,
      &quot;homepage&quot;: {
        &quot;@id&quot;: &quot;http://xmlns.com/foaf/0.1/homepage&quot;,
        &quot;@type&quot;, &quot;@id&quot;
      }
   },
   &quot;name&quot;: &quot;Manu Sporny&quot;,
   &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;
}</pre>

<p>Running the JSON-LD Expansion algorithm against the JSON-LD input document
  provided above would result in the following output:</p>

<pre class="example">{
   &quot;http://xmlns.com/foaf/0.1/name&quot;: &quot;Manu Sporny&quot;,
   &quot;http://xmlns.com/foaf/0.1/homepage&quot;: {
      &quot;@id&quot;: &quot;http://manu.sporny.org/&quot;
   }
}</pre>

<div id="expansion-algorithm" typeof="bibo:Chapter" resource="#expansion-algorithm" rel="bibo:chapter" class="section">
<h4><span class="secno">3.9.1 </span>Expansion Algorithm</h4>

<p>The algorithm takes three input variables: an <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>,  an <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>, and an <em>element</em> to be expanded. To
  begin, the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> is set to the result of performing, <a href="#context-processing">Context Processing</a> on the passed
  <em>context</em>, or to the <a class="tref internalDFN" title="initial_context" href="#dfn-initial_context">initial context</a> if <em>context</em>
  is <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> is set to
  <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, and <em>element</em> is set to the <a class="tref internalDFN" title="json-ld_input" href="#dfn-json-ld_input">JSON-LD
  input</a>.</p>
<ol class="algorithm">
  <li>If <em>element</em> is an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, process each entry in <em>element</em> recursively
    using this algorithm, passing copies of the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> and <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>.
    If has a <code>@container</code> set to <code>@list</code> and any entry in <em>element</em> is an
    <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, or is a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> containing a <code>@list</code> property,
    throw an exception, as lists of lists are not allowed.
    If the expanded entry is null, drop it. If it's an array, merge its entries with <em>element</em>'s entries.</li>
  <li>Otherwise, if <em>element</em> is an object
    <ol class="algorithm">
      <li>If <em>element</em> has a <code>@context</code> property, update the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> according to
        the steps outlined in <a href="#context-processing">Context Processing</a> and remove the <code>@context</code>
        property.</li>
      <li>Then, proceed and process each <em>property</em> and <em>value</em> in <em>element</em> as follows:
        <ol class="algorithm">
          <li>Remove <em>property</em> from <em>element</em>, expand
            <em>property</em> according to the steps outlined in <a href="#iri-expansion"><abbr title="Internationalized Resource Identifier">IRI</abbr> Expansion</a>.
            Set the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> to the original un-expanded <em>property</em> if
            <em>property</em> is not a <a class="tref internalDFN" title="keyword" href="#dfn-keyword">keyword</a>.</li>
          <li>If <em>property</em> does not expand to a keyword or an <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a> (i.e., it doesn't contain a colon),
            continue with the next property from <em>element</em>.</li>
          <li>If <em>value</em> is <a class="tref internalDFN" title="null" href="#dfn-null">null</a> and <em>property</em> is not <code>@value</code>, continue with the next
            property from <em>element</em>.</li>
          <li>If the <em>property</em> is <code>@id</code> the <em>value</em> <em class="rfc2119" title="must">must</em> be a <a class="tref internalDFN" title="string" href="#dfn-string">string</a>.
            Expand the <em>value</em> according to <a href="#iri-expansion"><abbr title="Internationalized Resource Identifier">IRI</abbr> Expansion</a>.</li>
          <li>Otherwise, if the <em>property</em> is <code>@type</code>:
            <ol class="algorithm">
              <li>If <em>value</em> is a <a class="tref internalDFN" title="string" href="#dfn-string">string</a>, expand according to <a href="#iri-expansion"><abbr title="Internationalized Resource Identifier">IRI</abbr> Expansion</a>.</li>
              <li>Otherwise, if <em>value</em> is a <a class="tref internalDFN" title="subject_reference" href="#dfn-subject_reference">subject reference</a>, the expanded value
                is the result of performing <a href="#iri-expansion"><abbr title="Internationalized Resource Identifier">IRI</abbr> Expansion</a> on the value of <code>@id</code>.</li>
              <li>Otherwise, if <em>value</em> is a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON Object</a>, it must be empty (used for
                <a href="#framing">Framing</a>).</li>
              <li>Otherwise, if <em>value</em> is an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, all elements must be either a
                <a class="tref internalDFN" title="string" href="#dfn-string">string</a> or <a class="tref internalDFN" title="subject_reference" href="#dfn-subject_reference">subject reference</a>. Expand <em>value</em> for each
                of its entries using the previous three steps.</li>
            </ol>
          </li>
          <li>Otherwise, if the <em>property</em> is <code>@value</code> or <code>@language</code> the <em>value</em> <em class="rfc2119" title="must not">must not</em> be a
            <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> or an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>.</li>
          <li>Otherwise, if the <em>property</em> is <code>@list</code> or <code>@set</code> expand <em>value</em>
            recursively using this algorithm, passing copies of the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> and <em>active property</em>. If the expanded
            <em>value</em> is not an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, convert it to an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>.
            If <em>property</em> is <code>@list</code> and any entry in <em>value</em> is a
            <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> containing an <code>@list</code> property, throw an exception, as
            lists of lists are not supported.</li>
          <li>Otherwise, expand <em>value</em> recursively using this algorithm, passing copies of the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> and
            <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>.</li>
          <li>If <em>property</em> is not a keyword
            and <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> has a <code>@container</code> <code>@list</code>
            and the expanded <em>value</em> is not <a class="tref internalDFN" title="null" href="#dfn-null">null</a>,
            convert <em>value</em> to an <a class="tref internalDFN" title="object" href="#dfn-object">object</a> with an <code>@list</code> property whose value is
            set to <em>value</em> (unless <em>value</em> is already in that form).</li>
          <li>Convert <em>value</em> to <a class="tref internalDFN" title="array" href="#dfn-array">array</a> form unless <em>value</em> is <a class="tref internalDFN" title="null" href="#dfn-null">null</a> or <em>property</em> is
            <code>@id</code>, <code>@type</code>, <code>@value</code>, or <code>@language</code>.</li>
          <li>If <em>value</em> is not <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, either merge <em>value</em> into an existing <em>property</em> property of
            <em>element</em> or create a new <em>property</em> property with <em>value</em> as value.</li>
        </ol>
      </li>
      <li>If the processed <em>element</em> has an <code>@value</code> property
        <ol class="algorithm">
          <li><em>element</em> <em class="rfc2119" title="must not">must not</em> have more than one other property, which can either be <code>@language</code> or <code>@type</code>
            with a <a class="tref internalDFN" title="string" href="#dfn-string">string</a> value.</li>
          <li>if the value of <code>@value</code> equals <a class="tref internalDFN" title="null" href="#dfn-null">null</a>,
            replace <em>element</em> with the value of <code>@value</code>.</li>
        </ol>
      </li>
      <li>Otherwise, if <em>element</em> has an <code>@type</code> property and its value is not in the form of an
        <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, convert it to an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>.</li>
      <li>If <em>element</em> has an <code>@set</code> or <code>@list</code> property, it <em class="rfc2119" title="must">must</em> be the only property.
        Set <em>element</em> to the value of <code>@set</code>; leave <code>@list</code> untouched.</li>
      <li>If <em>element</em> has just a <code>@language</code> property, set <em>element</em> to <a class="tref internalDFN" title="null" href="#dfn-null">null</a>.</li>
    </ol>
  </li>
  <li>Otherwise, expand <em>element</em> according to the <a href="#value-expansion">Value Expansion</a> rules,
    passing copies of the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> and <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>.</li>
</ol>

<p>If, after the algorithm outlined above is run, the resulting <em>element</em> is an <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> with just a <code>@graph</code>
  property, <em>element</em> is set to the value of <code>@graph</code>'s value. Finally, if <em>element</em> is a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a>,
  it is wrapped into an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>.</p>

</div>

</div>

<div id="compaction" typeof="bibo:Chapter" resource="#compaction" rel="bibo:chapter" class="section">
<h3><span class="secno">3.10 </span>Compaction</h3>

<p>Compaction is the process of taking a JSON-LD document and applying a
  context such that the most compact form of the document is generated. JSON
  is typically expressed in a very compact, key-value format. That is, full
  IRIs are rarely used as keys. At times, a JSON-LD document may be received
  that is not in its most compact form. JSON-LD, via the API, provides a way
  to compact a JSON-LD document.</p>

<p>For example, assume the following JSON-LD input document:</p>

<pre class="example">{
  &quot;http://xmlns.com/foaf/0.1/name&quot;: &quot;Manu Sporny&quot;,
  &quot;http://xmlns.com/foaf/0.1/homepage&quot;: {
    &quot;@id&quot;: &quot;http://manu.sporny.org/&quot;
  }
}</pre>

<p>Additionally, assume the following developer-supplied JSON-LD context:</p>

<pre class="example">{
  &quot;@context&quot;: {
    &quot;name&quot;: &quot;http://xmlns.com/foaf/0.1/name&quot;,
    &quot;homepage&quot;: {
      &quot;@id&quot;: &quot;http://xmlns.com/foaf/0.1/homepage&quot;,
      &quot;@type&quot;: &quot;@id&quot;
    }
  }
}</pre>

<p>Running the JSON-LD Compaction algorithm given the context supplied above
  against the JSON-LD input document provided above would result in the following
  output:</p>

<pre class="example">{
  &quot;@context&quot;: {
    &quot;name&quot;: &quot;http://xmlns.com/foaf/0.1/name&quot;,
    &quot;homepage&quot;: {
      &quot;@id&quot;: &quot;http://xmlns.com/foaf/0.1/homepage&quot;,
      &quot;@type&quot;: &quot;@id&quot;
    }
  },
  &quot;name&quot;: &quot;Manu Sporny&quot;,
  &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;
}</pre>

<p>The compaction algorithm also enables the developer to map any expanded
  format into an application-specific compacted format. While the context
  provided above mapped <code>http://xmlns.com/foaf/0.1/name</code> to
  <strong>name</strong>, it could have also mapped it to any arbitrary string
  provided by the developer.</p>

<div id="compaction-algorithm" typeof="bibo:Chapter" resource="#compaction-algorithm" rel="bibo:chapter" class="section">
<h4><span class="secno">3.10.1 </span>Compaction Algorithm</h4>

<p>The algorithm takes three input variables: an <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>, an <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>,
  and an <em>element</em> to be compacted. To begin, the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> is
  set to the result of performing <a href="#context-processing">Context Processing</a> on the passed <em>context</em>,
  <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> is set to <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, and <em>element</em> is set to the result of performing the
  <a href="#expansion-algorithm">Expansion Algorithm</a> on the <a class="tref internalDFN" title="json-ld_input" href="#dfn-json-ld_input">JSON-LD input</a>. This removes any existing
  context to allow the given <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> to be cleanly applied.</p>

<ol class="algorithm">
  <li>If <em>element</em> is an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, process each entry in <em>element</em> recursively
    using this algorithm, passing a copy of the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> and the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>.
    If <em>element</em> has a single item, the compacted value is that item; otherwise the compacted value
    is <em>element</em>.</li>
  <li>Otherwise, if <em>element</em> is an object:
    <ol class="algorithm">
      <li>If <em>element</em> has an <code>@value</code> property or element is a <a class="tref internalDFN" title="subject_reference" href="#dfn-subject_reference">subject reference</a>,
        return the result of performing
        <a href="#value-compaction">Value Compaction</a> on <em>element</em> using <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>.</li>
      <li>Otherwise, if the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> has a <code>@container</code> mapping to <code>@list</code>
        and <em>element</em> has a corresponding <code>@list</code> property, recursively compact that
        property's value passing a copy of the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> and the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> ensuring
        that the result is an array and removing <a class="tref internalDFN" title="null" href="#dfn-null">null</a> values. Return either the
        result as an array, as an object with a key of <code>@list</code> (or appropriate alias from
        <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>).</li>
      <li>Otherwise, construct <em>output</em> as a new <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> used for returning the result
        of compacting <em>element</em>. For each <em>property</em> and <em>value</em> in <em>element:</em>
        <ol class="algorithm">
          <li>If <em>property</em> is <code>@id</code> or <code>@type</code>
            <ol class="algorithm">
              <li>Set <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> to the result of performing
                <a href="#iri-compaction"><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction</a> on <em>property</em>.</li>
              <li>If <em>value</em> is a <a class="tref internalDFN" title="string" href="#dfn-string">string</a>, the compacted <em>value</em> is the result of performing
                <a href="#iri-compaction"><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction</a> on <em>value</em>.</li>
              <li>Otherwise, <em>value</em> <em class="rfc2119" title="must">must</em> be an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>. Perform <a href="#iri-compaction"><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction</a>
                on every entry of <em>value</em>. If <em>value</em> contains just one entry, <em>value</em> is set to that entry.</li>
              <li>Add <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> and the expanded <em>value</em> to <em>output</em>.</li>
            </ol>
          </li>
          <li>Otherwise, <em>value</em> <em class="rfc2119" title="must">must</em> be an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>.</li>
          <li>If <em>value</em> is empty:
            <ol class="algorithm">
              <li>Set <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> to the result of performing
                <a href="#iri-compaction"><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction</a> on <em>property</em>.</li>
              <li>Create an entry in <em>output</em> for <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> and <em>value</em>.</li>
            </ol>
          </li>
          <li>For each <em>item</em> in <em>value</em>:
            <ol class="algorithm">
              <li>Set <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> to the result of performing <a href="#iri-compaction"><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction</a>
                for <em>property</em> and <em>item</em> using the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>.</li>
              <li>Compact <em>item</em> by recursively performing this algorithm passing a copy of
                the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> and the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>.</li>
              <li>If an entry already exists in <em>output</em> for <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>, convert it
                to an <a class="tref internalDFN" title="array" href="#dfn-array">array</a> if necessary, and append the compacted <em>value</em>.</li>
              <li>Otherwise, if the compacted <em>value</em> is not an <a class="tref internalDFN" title="array" href="#dfn-array">array</a> and <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>
                has a <code>@container</code> mapping to <code>@set</code>,
                create an entry in <em>output</em> for <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> and <em>value</em> as an
                <a class="tref internalDFN" title="array" href="#dfn-array">array</a>.</li>
              <li>Otherwise, create an entry in <em>output</em> for <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> and <em>value</em>.</li>
            </ol>
          </li>
        </ol>
      </li>
    </ol>
  </li>
  <li>Otherwise, return <em>element</em> as the compacted <em>element</em>.
    <div class="issue">Perhaps this should also call <a href="#value-compaction">Value Compaction</a> on
      native types and strings, which could consolodate potential transformation in one place.</div>
  </li>
</ol>

<p>If, after the algorithm outlined above is run, the resulting <em>element</em> is an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, put <em>element</em> into the
  <code>@graph</code> property of a new <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> and then set <em>element</em> to that <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a>.
  Finally, add a <code>@context</code> property to <em>element</em> and set it to the initially passed <em>context</em>.</p>

</div>

</div>

<div id="framing" typeof="bibo:Chapter" resource="#framing" rel="bibo:chapter" class="section">
<h3><span class="secno">3.11 </span>Framing</h3>

<p>JSON-LD Framing allows developers to query by example and
  force a specific tree layout to a JSON-LD document.</p>

<p>A JSON-LD document is a representation of a directed graph. A single
  directed graph can have many different serializations, each expressing
  exactly the same information. Developers typically work with trees, represented as
  <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a>s. While mapping a graph to
  a tree can be done, the layout of the end result must be specified in advance.
  A <dfn title="frame" id="dfn-frame">Frame</dfn> can be used by a developer on a JSON-LD document to
  specify a deterministic layout for a graph.</p>

<p>Framing is the process of taking a JSON-LD document, which expresses a
  graph of information, and applying a specific graph layout
  (called a <a class="tref internalDFN" title="frame" href="#dfn-frame">Frame</a>).</p>

<p>Framing makes use of the <a href="#subject-map-generation">Subject Map Generation</a> algorithm
  to place each object defined in the JSON-LD document into a flat list of objects, allowing
  them to be operated upon by the framing algorithm.</p>

<div id="framing-algorithm-terms" typeof="bibo:Chapter" resource="#framing-algorithm-terms" rel="bibo:chapter" class="section">
<h4><span class="secno">3.11.1 </span>Framing Algorithm Terms</h4>

<dl>
  <dt><dfn title="input_frame" id="dfn-input_frame">input frame</dfn></dt>
  <dd>the initial <a class="tref internalDFN" title="frame" href="#dfn-frame">frame</a> provided to the framing algorithm.</dd>
  <dt><dfn title="framing_context" id="dfn-framing_context">framing context</dfn></dt>
  <dd>a context containing a <a class="tref internalDFN" title="map_of_embeds" href="#dfn-map_of_embeds">map of embeds</a>, the
    <a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag">object embed flag</a>, the
    <a class="tref internalDFN" title="explicit_inclusion_flag" href="#dfn-explicit_inclusion_flag">explicit inclusion flag</a> and the
    <a class="tref internalDFN" title="omit_default_flag" href="#dfn-omit_default_flag">omit default flag</a>.</dd>
  <dt><dfn title="map_of_embeds" id="dfn-map_of_embeds">map of embeds</dfn></dt>
  <dd>a map that tracks if a subject is to be embedded in the output of the
    <a href="#framing-algorithm">Framing Algorithm</a>; it maps a subject
    <code>@id</code> to a parent <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> and property
    or parent array.</dd>
  <dt><dfn title="object_embed_flag" id="dfn-object_embed_flag">object embed flag</dfn></dt>
  <dd>a flag specifying that objects should be directly embedded in the output,
    instead of being referred to by their <abbr title="Internationalized Resource Identifier">IRI</abbr>.</dd>
  <dt><dfn title="explicit_inclusion_flag" id="dfn-explicit_inclusion_flag">explicit inclusion flag</dfn></dt>
  <dd>a flag specifying that for properties to be included in the output, they
    must be explicitly declared in the <a class="tref internalDFN" title="framing_context" href="#dfn-framing_context">framing context</a>.</dd>
  <dt><dfn title="omit_default_flag" id="dfn-omit_default_flag">omit default flag</dfn></dt>
  <dd>a flag specifying that properties that are missing from the
    <a class="tref internalDFN" title="json-ld_input" href="#dfn-json-ld_input">JSON-LD input</a>, but present in the <a class="tref internalDFN" title="input_frame" href="#dfn-input_frame">input frame</a>
    should be omitted from the output.</dd>
  <dt><dfn title="map_of_flattened_subjects" id="dfn-map_of_flattened_subjects">map of flattened subjects</dfn></dt>
  <dd>a map of subjects that is the result of the
    <a href="#subject-map-generation">Subject Map Generation algorithm</a>.</dd>
</dl>
</div>

<div id="framing-algorithm" typeof="bibo:Chapter" resource="#framing-algorithm" rel="bibo:chapter" class="section">
<h4><span class="secno">3.11.2 </span>Framing Algorithm</h4>

<p class="issue">This algorithm is a work in progress. Presently, it only works
  for documents without named graphs.</p>

<p>The framing algorithm takes an <a class="tref internalDFN" title="json-ld_input" href="#dfn-json-ld_input">JSON-LD input</a> (<strong>expanded input</strong>)
  and an <a class="tref internalDFN" title="input_frame" href="#dfn-input_frame">input frame</a> (<strong>expanded frame</strong>) that have been expanded
  according to the <a href="#expansion-algorithm">Expansion Algorithm</a>, and a number of
  options and produces <a class="tref internalDFN" title="json-ld_output" href="#dfn-json-ld_output">JSON-LD output</a>.</p>

<p>Create <a class="tref internalDFN" title="framing_context" href="#dfn-framing_context">framing context</a> using <a class="tref internalDFN" title="null" href="#dfn-null">null</a> for the <a class="tref internalDFN" title="map_of_embeds" href="#dfn-map_of_embeds">map of embeds</a>,
    the <a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag">object embed flag</a> set to <a class="tref internalDFN" title="true" href="#dfn-true">true</a>, the
    <a class="tref internalDFN" title="explicit_inclusion_flag" href="#dfn-explicit_inclusion_flag">explicit inclusion flag</a> set to <a class="tref internalDFN" title="false" href="#dfn-false">false</a>, and the
    <a class="tref internalDFN" title="omit_default_flag" href="#dfn-omit_default_flag">omit default flag</a> set to <a class="tref internalDFN" title="false" href="#dfn-false">false</a> along with <a class="tref internalDFN" title="map_of_flattened_subjects" href="#dfn-map_of_flattened_subjects">map of flattened subjects</a>
    set to the <code>@merged</code> property of the result of performing the
    <a href="#subject-map-generation">Subject Map Generation</a> algorithm on
    <strong>expanded input</strong>. Also create <em>results</em> as an empty <a class="tref internalDFN" title="array" href="#dfn-array">array</a>.</p>

<p>Invoke the recursive algorithm using <a class="tref internalDFN" title="framing_context" href="#dfn-framing_context">framing context</a> (<em>state</em>),
  the <a class="tref internalDFN" title="map_of_flattened_subjects" href="#dfn-map_of_flattened_subjects">map of flattened subjects</a> (<em>subjects</em>),
  <strong>expanded frame</strong> (<em>frame</em>), <em>result</em> as <em>parent</em>, and
  <a class="tref internalDFN" title="null" href="#dfn-null">null</a> as <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>.</p>

<p>The following series of steps is the recursive
  portion of the framing algorithm:</p>

<ol class="algorithm">
  <li>Validate <em>frame</em>.</li>
  <li>Create a set of matched subjects by filtering <em>subjects</em> checking
    the <a class="tref internalDFN" title="map_of_flattened_subjects" href="#dfn-map_of_flattened_subjects">map of flattened subjects</a> against <em>frame</em>:
    <ol class="algorithm">
      <li>If <em>frame</em> has a <code>@type</code> property containing
        one or more <a class="tref internalDFN" title="iri" href="#dfn-iri">IRIs</a> match any <a class="tref internalDFN" title="subject_definition" href="#dfn-subject_definition">subject definition</a>
        with a <code>@type</code> property including any of those <a class="tref internalDFN" title="iri" href="#dfn-iri">IRIs</a>.</li>
      <li>Otherwise, if <em>frame</em> has a <code>@type</code> property only
        a empty <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a>, matches any <a class="tref internalDFN" title="subject_definition" href="#dfn-subject_definition">subject definition</a>
        with a <code>@type</code> property, regardless of the actual values.</li>
      <li>Otherwise, match if the <a class="tref internalDFN" title="subject_definition" href="#dfn-subject_definition">subject definition</a> contains all of the
        non-<a class="tref internalDFN" title="keyword" href="#dfn-keyword">keyword</a> properties in <em>frame</em>.</li>
    </ol>
  </li>
  <li>Get values for <em>embedOn</em> and <em>explicitOn</em> by looking in <em>frame</em>
    for the keys <code>@embed</code> and <code>@explicit</code> using the current values
    for <a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag">object embed flag</a> and <a class="tref internalDFN" title="explicit_inclusion_flag" href="#dfn-explicit_inclusion_flag">explicit inclusion flag</a> from <em>state</em> if not found.</li>
  <li>For each <em>id</em> and <em>subject</em> from the set of matched subjects, ordered by <em>id</em>:
    <ol class="algorithm">
      <li>If the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> is <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, set the <a class="tref internalDFN" title="map_of_embeds" href="#dfn-map_of_embeds">map of embeds</a> in
        <em>state</em> to an empty map.</li>
      <li>Initialize <em>output</em> with <code>@id</code> and <em>id</em>.</li>
      <li>Initialize <em>embed</em> with <em>parent</em> and <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> to
        <em>property</em>.</li>
      <li>If <em>embedOn</em> is <a class="tref internalDFN" title="true" href="#dfn-true">true</a>, and <em>id</em> is in <a class="tref internalDFN" title="map_of_embeds" href="#dfn-map_of_embeds">map of embeds</a>
        from <em>state</em>:
        <ol class="algorithm">
          <li>Set <em>existing</em> to the value of <em>id</em> in <a class="tref internalDFN" title="map_of_embeds" href="#dfn-map_of_embeds">map of embeds</a>
            and set <em>embedOn</em> to <a class="tref internalDFN" title="false" href="#dfn-false">false</a>.</li>
          <li>If <em>existing</em> has a <em>parent</em> which is an <a class="tref internalDFN" title="array" href="#dfn-array">array</a> containing a
            <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> with <code>@id</code> equal to <em>id</em>, <em>element</em> has
            already been embedded and can be overwritten, so set <em>embedOn</em> to <a class="tref internalDFN" title="true" href="#dfn-true">true</a>.</li>
          <li>Otherwise, <em>existing</em> has a <em>parent</em> which is a <a class="tref internalDFN" title="subject_definition" href="#dfn-subject_definition">subject definition</a>.
            Set <em>embedOn</em> to <a class="tref internalDFN" title="true" href="#dfn-true">true</a> if any of the items in <em>parent</em> <em>property</em>
            is a <a class="tref internalDFN" title="subject_definition" href="#dfn-subject_definition">subject definition</a>
            or <a class="tref internalDFN" title="subject_reference" href="#dfn-subject_reference">subject reference</a> for <em>id</em> because the embed can be overwritten.
          </li>
          <li>If <em>embedOn</em> is <a class="tref internalDFN" title="true" href="#dfn-true">true</a>, <em>existing</em> is already embedded but
            can be overwritten, so <a href="#remove-embed">Remove Embedded Definition</a> for <em>id</em>.
          </li>
        </ol>
      </li>
      <li>If <em>embedOn</em> is <a class="tref internalDFN" title="false" href="#dfn-false">false</a>, add <em>output</em> to <em>parent</em>
        by either appending to <em>parent</em> if it is an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, or appending
        to <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> in <em>parent</em> otherwise.</li>
      <li>Otherwise:
        <ol class="algorithm">
          <li>Add <em>embed</em> to <a class="tref internalDFN" title="map_of_embeds" href="#dfn-map_of_embeds">map of embeds</a> for <em>id</em>.</li>
          <li>Process each <em>property</em> and <em>value</em> in the matched <em>subject</em>, ordered
            by <em>property</em>:
            <ol class="algorithm">
              <li>If <em>property</em> is a <a class="tref internalDFN" title="keyword" href="#dfn-keyword">keyword</a>, add <em>property</em> and a copy of <em>value</em>
                to <em>output</em> and continue with the next property from <em>subject</em>.</li>
              <li>If <em>property</em> is not in <em>frame</em>:
                <ol class="algorithm">
                  <li>If <em>explicitOn</em> is <a class="tref internalDFN" title="false" href="#dfn-false">false</a>, <a href="#embed-values">Embed values</a>
                    from <em>subject</em> in <em>output</em> using <em>subject</em> as <em>element</em> and
                    <em>property</em> as <em>active property</em>.</li>
                  <li>Continue to next property.</li>
                </ol>
              </li>
              <li id="frm-process-prop-item">Process each <em>item</em> from <em>value</em> as follows:
                <ol class="algorithm">
                  <li>If <em>item</em> is a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> with the key <code>@list</code>, then
                    create a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> named <em>list</em> with the key <code>@list</code> and
                    the value of an empty array. Append <em>list</em> to <em>property</em> in
                    <em>output</em>. Process each <em>listitem</em> in the <code>@list</code> array as follows:
                    <ol class="algorithm">
                      <li>If <em>listitem</em> is a <a class="tref internalDFN" title="subject_reference" href="#dfn-subject_reference">subject reference</a>
                        process <em>listitem</em> recursively using this algorithm passing a new map of
                        <em>subjects</em> that contains the <code>@id</code> of <em>listitem</em> as the key
                        and the <a class="tref internalDFN" title="subject_definition" href="#dfn-subject_definition">subject definition</a> from the original <a class="tref internalDFN" title="map_of_flattened_subjects" href="#dfn-map_of_flattened_subjects">map of flattened subjects</a>
                        as the value. Pass the first value from
                        <em>frame</em> for <em>property</em> as <em>frame</em>, <em>list</em>
                        as <em>parent</em>, and <code>@list</code> as <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>.</li>
                      <li>Otherwise, append a copy of <em>listitem</em> to <code>@list</code> in <em>list</em>.</li>
                    </ol>
                  </li>
                  <li>If <em>item</em> is a <a class="tref internalDFN" title="subject_reference" href="#dfn-subject_reference">subject reference</a>
                    process <em>item</em> recursively using this algorithm passing a new map as
                    <em>subjects</em> that contains the <code>@id</code> of <em>item</em> as the key and
                    the <a class="tref internalDFN" title="subject_definition" href="#dfn-subject_definition">subject definition</a> from the original <a class="tref internalDFN" title="map_of_flattened_subjects" href="#dfn-map_of_flattened_subjects">map of flattened subjects</a>
                    as the value. Pass the first value from
                    <em>frame</em> for <em>property</em> as <em>frame</em>, <em>output</em>
                    as <em>parent</em>, and <em>property</em> as <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>.
                  <div class="issue">Passing a <a class="tref internalDFN" title="subject_reference" href="#dfn-subject_reference">subject reference</a> doesn't work if this map
                    is used recursively. Presently pass <a class="tref internalDFN" title="subject_definition" href="#dfn-subject_definition">subject definition</a> from original
                    <a class="tref internalDFN" title="map_of_flattened_subjects" href="#dfn-map_of_flattened_subjects">map of flattened subjects</a>.</div></li>
                  <li>Otherwise, append a copy of <em>item</em> to <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> in
                    <em>output</em>.</li>
                </ol>
              </li>
            </ol>
          </li>
          <li>Process each <em>property</em> and <em>value</em> in <em>frame</em>,
            where <em>property</em> is not a <em>keyword</em>, ordered by <em>property</em>:
            <ol class="algorithm">
              <li>Set <em>property frame</em> to the first item in <em>value</em> or a newly created
                <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> if <em>value</em> is empty.</li>
              <li>Skip to the next property in <em>frame</em> if <em>property</em> is in <em>output</em>
                or if <em>property frame</em> contains
                <code>@omitDefault</code> which is <a class="tref internalDFN" title="true" href="#dfn-true">true</a> or if it does not contain
                <code>@omitDefault</code> but the value of <a class="tref internalDFN" title="omit_default_flag" href="#dfn-omit_default_flag">omit default flag</a>
                <a class="tref internalDFN" title="true" href="#dfn-true">true</a>.</li>
              <li>Set the value of <em>property</em> in <em>output</em> to a new <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a>
                with a property <code>@preserve</code> and a value that is a copy of the value
                of <code>@default</code> in <em>frame</em> if it exists, or the string
                <code>@null</code> otherwise.</li>
            </ol>
          </li>
          <li>Add <em>output</em> to <em>parent</em>.
            If <em>parent</em> is an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, append <em>output</em>, otherwise
            append <em>output</em> to <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> in <em>parent</em>.</li>
        </ol>
      </li>
    </ol>
  </li>
</ol>

<p>At the completion of the recursive algorithm, <em>results</em> will contain the top-level
  <a class="tref internalDFN" title="subject_definition" href="#dfn-subject_definition">subject definition</a>s.</p>
<p>The final two steps of the framing algorithm require
  <em>results</em> to be compacted according to the
  <a href="#compaction-algorithm">Compaction Algorithm</a> by using the
  context provided in the <a class="tref internalDFN" title="input_frame" href="#dfn-input_frame">input frame</a>. If the frame has no context, compaction
  is performed with an empty context (not a null context). The compaction result <em class="rfc2119" title="must">must</em> use
  the <code>@graph</code> keyword at the top-level, even if the context is empty or if there
  is only one element to put in the <code>@graph</code> array. Subsequently, replace all key-value
  pairs where the key is <code>@preserve</code> with the value from the key-pair. If the value
  from the key-pair is <code>@null</code>, replace the value with <a class="tref internalDFN" title="null" href="#dfn-null">null</a>. If,
  after replacement, an array contains only the value <a class="tref internalDFN" title="null" href="#dfn-null">null</a> remove the value, leaving
  an empty array. The resulting value is the final <a class="tref internalDFN" title="json-ld_output" href="#dfn-json-ld_output">JSON-LD output</a>.</p>

<p class="issue">The algorithm needs to be updated to consider <code>@graph</code>. See
  <a href="https://github.com/json-ld/json-ld.org/issues/118">ISSUE-118</a> for details.</p>

</div>

<div id="subject-map-generation" typeof="bibo:Chapter" resource="#subject-map-generation" rel="bibo:chapter" class="section">
<h4><span class="secno">3.11.3 </span>Subject Map Generation</h4>
<p>The Subject Map Generation algorithm takes as input an expanded JSON-LD document and results in a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a>
  <em>subjectMap</em> holding a flat representation of the graphs and nodes represented in the document. All nodes that are not
  uniquely identified by an <abbr title="Internationalized Resource Identifier">IRI</abbr> get assigned a (new) <a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">blank node</a> identifier. The resulting <em>subjectMap</em>
  document will have a property for every graph in the document whose value is another object with a property for every
  node represented in the document. While the default graph is stored under the <code>@default</code> property and the merged graph
  under the <code>@merged</code> property, all other graphs are stored under their respective <a class="tref internalDFN" title="iri" href="#dfn-iri">IRIs</a>.</p>

<p>The algorithm takes as input the expanded JSON-LD document as <em>element</em>, the initially empty <em>subjectMap</em>,
  <code>@default</code> as <em>graph</em>, and <a class="tref internalDFN" title="null" href="#dfn-null">null</a> as <em>list</em>.</p>

<ol class="algorithm">
  <li>If <em>element</em> is an array, process each entry in <em>element</em> recursively, using this algorithm
    and return.</li>
  <li>If <em>element</em> is not a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> or if it has a <code>@value</code> property,
    then if <em>list</em> is not <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, append <em>element</em> to <em>list</em> and return.</li>
  <li>If the <code>@id</code> property exists and is an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>, set <em>id</em> to its value, otherwise
    set it to a <a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">blank node</a> identifer created by the
    <a href="#generate-blank-node-identifier">Generate Blank Node Identifier</a> algorithm.</li>
  <li>If <em>list</em> is not <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, append a new <a class="tref internalDFN" title="subject_reference" href="#dfn-subject_reference">subject reference</a> to <em>list</em> using
    <em>id</em> at the value for <code>@id</code>.</li>
  <li>Let <em>subjects</em> be the value in <em>subjectMap</em> where the key is <em>graph</em>; if no such
    value exists, insert a new <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> for the key <em>graph</em>. If <em>id</em> is not in
    <em>subjects</em>, create a new <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> <em>subject</em> with <em>id</em> as the value
    for <code>@id</code>. Let <em>subject</em> be the value of <em>id</em> in <em>subjects</em>.</li>
  <li>For each <em>property</em> that is not <code>@id</code> and each <em>value</em> in <em>element</em> ordered
    by <em>property</em>:
    <ol class="algorithm">
      <li>If <em>property</em> is <code>@graph</code>, recursively call this algorithm passing <em>value</em>
        for <em>element</em>, <em>subjectMap</em>, <a class="tref internalDFN" title="null" href="#dfn-null">null</a> for <em>list</em> and if <em>graph</em>
        is <code>merged</code> use <em>graph</em>, otherwise use <em>id</em> for <em>graph</em> and then continue.</li>
      <li>If <em>property</em> is not <code>@type</code> and is a keyword, merge <code>property</code> and
        <code>value</code> into <code>subject</code> and then continue.</li>
      <li>For each value <em>v</em> in the array <em>value</em>:
        <ol class="algorithm">
          <li>If <em>v</em> is a <a class="tref internalDFN" title="subject_definition" href="#dfn-subject_definition">subject definition</a> or <a class="tref internalDFN" title="subject_reference" href="#dfn-subject_reference">subject reference</a>:
            <ol class="algorithm">
              <li>If the property <code>@id</code> is not an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a> or it does not exist,
                map <em>v</em> to a <a href="#generate-blank-node-identifier">new blank node identifier</a>
                to avoid collisions. If one does not already exist, add a <a class="tref internalDFN" title="subject_reference" href="#dfn-subject_reference">subject reference</a> for
                <em>v</em> into <em>subject</em> for <em>property</em>.</li>
              <li>Recursively call this algorithm passing <em>v</em> for <em>value</em>, <em>subjectMap</em>,
                <em>graph</em>, and <a class="tref internalDFN" title="null" href="#dfn-null">null</a> for <em>list</em>.</li>
            </ol>
          </li>
          <li>Otherwise if <em>v</em> has the property <code>@list</code> then recursively call this algorithm
            with the value of <code>@list</code> as <em>element</em>, <em>subjectMap</em>, <em>graph</em>, and
            a new array <em>flattenedList</em> as <em>list</em>. Create a new <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> with the
            property <code>@list</code> set to <em>flattenedList</em> and add it to <em>subject</em> for
            <em>property</em>.</li>
          <li>Otherwise, if <em>property</em> is <code>@type</code> and <em>v</em> is not an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>,
            generate a <a href="#generate-blank-node-identifier">new blank node identifier</a> and add it
            to <em>subject</em> for <em>property</em>.</li>
          <li>Otherwise, add <em>v</em> to <em>subject</em> for <em>property</em>.</li>
        </ol>
      </li>
    </ol>
  </li>
</ol>

<p>After the above outlined algorithm has been executed, the subject map for all graphs including the default graph are contained in
  <em>subjectMap</em>. To also create the subject map for the merged graph, execute the algorithm again, but pass <code>merged</code>
  for <em>graph</em>.</p>

</div>

<div id="remove-embed" typeof="bibo:Chapter" resource="#remove-embed" rel="bibo:chapter" class="section">
<h4><span class="secno">3.11.4 </span>Remove Embedded Definition</h4>
<p>This algorithm replaces an already embedded <a class="tref internalDFN" title="subject_definition" href="#dfn-subject_definition">subject definition</a> with a
  <a class="tref internalDFN" title="subject_reference" href="#dfn-subject_reference">subject reference</a>. It then recursively removes any entries in the
  <a class="tref internalDFN" title="map_of_embeds" href="#dfn-map_of_embeds">map of embeds</a> that had the removed <a class="tref internalDFN" title="subject_definition" href="#dfn-subject_definition">subject definition</a> in
  their parent chain.
  </p><div class="issue">About as clear as mud</div><p></p>
<p>The algorithm is invoked with a <a class="tref internalDFN" title="framing_context" href="#dfn-framing_context">framing context</a> and subject id <em>id</em>.</p>
<ol class="algorithm">
  <li>Find <em>embed</em> from <a class="tref internalDFN" title="map_of_embeds" href="#dfn-map_of_embeds">map of embeds</a> for <em>id</em>.</li>
  <li>Let <em>parent</em> and <em>property</em> be from <em>embed</em>.</li>
  <li>If <em>parent</em> is an array, replace the <a class="tref internalDFN" title="subject_definition" href="#dfn-subject_definition">subject definition</a> that matches
    <em>id</em> with a <a class="tref internalDFN" title="subject_reference" href="#dfn-subject_reference">subject reference</a>. If parent is a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a>,
    replace the <a class="tref internalDFN" title="subject_definition" href="#dfn-subject_definition">subject definition</a> for <em>property</em> that matches <em>id</em>
    with a <a class="tref internalDFN" title="subject_reference" href="#dfn-subject_reference">subject reference</a>.</li>
  <li>Remove dependents for <em>id</em> in <a class="tref internalDFN" title="map_of_embeds" href="#dfn-map_of_embeds">map of embeds</a>
    by scanning the map for entries with <em>parent</em> that have an <code>@id</code> of <em>id</em>,
    removing that definition from the map, and then removing the dependents for the <em>parent</em> id
    recursively by repeating this step. This step will terminate when there are no more embed
    entries containing the removed <a class="tref internalDFN" title="subject_definition" href="#dfn-subject_definition">subject definition</a>'s <code>@id</code> in their
    parent chain.</li>
</ol>
</div>

<div id="embed-values" typeof="bibo:Chapter" resource="#embed-values" rel="bibo:chapter" class="section">
<h4><span class="secno">3.11.5 </span>Embed Values</h4>
<p>This algorithm recursively embeds property values in <a class="tref internalDFN" title="subject_definition" href="#dfn-subject_definition">subject definition</a> <em>output</em>, given a
  <a class="tref internalDFN" title="framing_context" href="#dfn-framing_context">framing context</a>, input <a class="tref internalDFN" title="subject_definition" href="#dfn-subject_definition">subject definition</a> <em>element</em>, <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>,
  and <em>output</em>.</p>
<ol class="algorithm">
  <li>For each <em>item</em> in <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> of <em>element</em>:
    <ol class="algorithm">
      <li>If <em>item</em> is a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> with the key <code>@list</code>,
        then create a new <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> with a key <code>@list</code> and
        a value of an empty array and add it to <em>output</em>, appending if <em>output</em>
        is an array, and appending to <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> otherwise. Recursively call this
        algorithm passing <em>item</em> as <em>element</em>, <code>@list</code> as <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>,
        and the new array as <em>output</em>. Continue to the next <em>item</em>.</li>
      <li>If <em>item</em> is a <a class="tref internalDFN" title="subject_reference" href="#dfn-subject_reference">subject reference</a>:
        <ol class="algorithm">
          <li>If <a class="tref internalDFN" title="map_of_embeds" href="#dfn-map_of_embeds">map of embeds</a> does not contain an entry for the <code>@id</code> of <em>item</em>:
            <ol class="algorithm">
              <li>Initialize <em>embed</em> with <em>output</em> as <em>parent</em> and
                <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> as <em>property</em>
                and add to <a class="tref internalDFN" title="map_of_embeds" href="#dfn-map_of_embeds">map of embeds</a>.</li>
              <li>Initialize a new <a class="tref internalDFN" title="subject_definition" href="#dfn-subject_definition">subject definition</a> <em>o</em> to act as the
                embedded <a class="tref internalDFN" title="subject_definition" href="#dfn-subject_definition">subject definition</a>.</li>
              <li>For each <em>property</em> and <em>value</em> in the expanded definition for
                <em>item</em> in <em>subjects</em>:
                <ol class="algorithm">
                  <li>Add <em>property</em> and a copy of <em>value</em> to <em>o</em> if <em>property</em>
                    is a <a class="tref internalDFN" title="keyword" href="#dfn-keyword">keyword</a>.</li>
                  <li>Otherwise, recursively call this algorithm passing <em>value</em> as <em>element</em>,
                    <em>property</em> as <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> and <em>o</em> as <em>output</em>.</li>
                </ol>
              </li>
            </ol>
          </li>
          <li>Set <em>item</em> to <em>o</em>.</li>
        </ol>
      </li>
    </ol>
  </li>
  <li>If <em>output</em> is an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, append a copy of <em>item</em>, otherwise
    append a copy of <em>item</em> to <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> in <em>output</em>.</li>
</ol>
</div>
</div>

<div id="flattening" typeof="bibo:Chapter" resource="#flattening" rel="bibo:chapter" class="section">
<h3><span class="secno">3.12 </span>Flattening</h3>

<p>Flattening is the process of taking a JSON-LD document, <a href="#expansion">expanding</a>
  it, labeling all unlabeled nodes with a <a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">blank node</a> identifier, and returning
  an array of the nodes defined in the document.</p>

<p class="issue">It is still being discussed if the flatten() method should be added or not.
  See <a href="https://github.com/json-ld/json-ld.org/issues/109">ISSUE-109</a>.</p>

<p>For example, assume the following JSON-LD input document:</p>

<pre class="example">{
  &quot;@context&quot;: {
    &quot;name&quot;: &quot;http://xmlns.com/foaf/0.1/name&quot;,
    &quot;knows&quot;: &quot;foaf:knows&quot;
  },
  &quot;@id&quot;: &quot;http://example.com/markus&quot;,
  &quot;name&quot;: &quot;Markus Lanthaler&quot;,
  &quot;knows&quot;: {
    &quot;name&quot;: &quot;Manu Sporny&quot;
  }
}</pre>

<p>Running the JSON-LD Flattening algorithm for the merged graph (<code>@merged</code>) against
  the JSON-LD input document provided above would result in the following output:</p>

<pre class="example">[
  {
    &quot;@id&quot;: &quot;http://example.com/markus&quot;,
    &quot;foaf:knows&quot;: [ { &quot;@id&quot;: &quot;_:t0&quot; }
    ],
    &quot;http://xmlns.com/foaf/0.1/name&quot;: [ { &quot;@value&quot;: &quot;Markus Lanthaler&quot; } ]
  },
  {
    &quot;@id&quot;: &quot;_:t0&quot;,
    &quot;http://xmlns.com/foaf/0.1/name&quot;: [ { &quot;@value&quot;: &quot;Manu Sporny&quot; } ]
  }
]</pre>

<div id="flattening-algorithm" typeof="bibo:Chapter" resource="#flattening-algorithm" rel="bibo:chapter" class="section">
<h4><span class="secno">3.12.1 </span>Flattening Algorithm</h4>
<p>The algorithm takes two input variables, an <em>element</em> to flatten and the
  <em>graph</em> for which the node definitions should be returned. If <em>graph</em>
  is not set, it will default to <code>@merged</code> which represents the result of
  merging all graphs including the default graph (<code>@default</code>).</p>

<ol class="algorithm">
  <li>Expand <em>element</em> according the <a href="#expansion-algorithm">Expansion Algorithm</a>.</li>
  <li>Generate a <em>subjectMap</em> according the <a href="#subject-map-generation">Subject Map Generation Algorithm</a>.</li>
  <li>Initialize an empty array <em>result</em>.</li>
  <li>If <em>subjectMap</em> has no property <em>graph</em>, return <em>result</em>, otherwise set <em>definitions</em> to its value.</li>
  <li>Foreach <em>property</em> and <em>value</em> of of <em>definitions</em>:
    <ol class="algorithm">
      <li>Add <em>value</em> to <em>result</em>.</li>
    </ol>
  </li>
  <li>Return <em>result</em>.</li>
</ol>

</div>
</div>

<div id="rdf-conversion" typeof="bibo:Chapter" resource="#rdf-conversion" rel="bibo:chapter" class="section">
<h3><span class="secno">3.13 </span>RDF Conversion</h3>

<p>A JSON-LD document <em class="rfc2119" title="may">may</em> be converted between other RDF-compatible document
  formats using the algorithms specified in this section.</p>

<p>The JSON-LD Processing Model describes processing rules for extracting RDF
  from a JSON-LD document, and for transforming an array of <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a> retrieved by processing
  another serialization format into JSON-LD. Note that many uses of JSON-LD may not require
  generation of RDF.</p>

<p>The processing algorithms described in this section are provided in
  order to demonstrate how one might implement a JSON-LD to RDF processor.
  Conformant implementations are only required to produce the same type and
  number of quads during the output process and are not required to
  implement the algorithm exactly as described.</p>

<div class="informative section" id="overview" typeof="bibo:Chapter" resource="#overview" rel="bibo:chapter">
  <h4><span class="secno">3.13.1 </span>Overview</h4><p><em>This section is non-normative.</em></p>
  <p>
    JSON-LD is intended to have an easy to parse grammar that closely models existing
    practice in using JSON for describing object representations. This allows the use
    of existing libraries for parsing JSON.
  </p>
  <p>
    As with other grammars used for describing <a class="tref internalDFN" title="linked_data" href="#dfn-linked_data">Linked Data</a>, a key concept is that of
    a <dfn title="resource" id="dfn-resource">resource</dfn>. Resources may be of three basic types: <a class="datatype idlType" title="IRI" href="#idl-def-IRI"><code><abbr title="Internationalized Resource Identifier">IRI</abbr></code></a>, representing
    <a class="tref internalDFN" title="iri" href="#dfn-iri">IRIs</a> for describing
    externally named entities, <a href="#idl-def-BlankNode" class="idlType"><code>BlankNode</code></a>, resources for which an external name does not
    exist, or is not known, and <a class="datatype idlType" title="Literal" href="#idl-def-Literal"><code>Literal</code></a>, which describe terminal entities such as strings,
    dates and other representations having a lexical representation possibly including
    an explicit language or datatype.
  </p>
  <p>Data described with JSON-LD may be considered to be the representation of a graph made
    up of <a class="tref internalDFN" title="subject" href="#dfn-subject">subject</a> and <a class="tref internalDFN" title="object" href="#dfn-object">object</a> <a class="tref internalDFN" title="resource" href="#dfn-resource">resource</a>s related via a
    <a class="tref internalDFN" title="property" href="#dfn-property">property</a> <a class="tref internalDFN" title="resource" href="#dfn-resource">resource</a>.
    However, specific implementations may choose to operate on the document as a normal
    JSON description of objects having attributes.</p>
</div>

<div id="rdf-conversion-algorithm-terms" typeof="bibo:Chapter" resource="#rdf-conversion-algorithm-terms" rel="bibo:chapter" class="section">
  <h4><span class="secno">3.13.2 </span>RDF Conversion Algorithm Terms</h4>
  <dl>
    <dt><dfn title="graph_name" id="dfn-graph_name">graph name</dfn></dt>
    <dd>
      A <a class="datatype idlType" title="IRI" href="#idl-def-IRI"><code><abbr title="Internationalized Resource Identifier">IRI</abbr></code></a> or <a class="datatype idlType" title="BlankNode" href="#idl-def-BlankNode"><code>BlankNode</code></a> used to identify quads belonging to a
      <em>named graph</em>.
    </dd>
  </dl>
</div>

<div id="convert-to-rdf-algorithm" typeof="bibo:Chapter" resource="#convert-to-rdf-algorithm" rel="bibo:chapter" class="section">
  <h4><span class="secno">3.13.3 </span>Convert to RDF Algorithm</h4>
  <p>
    The algorithm below is designed for in-memory implementations with random access to <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> elements.
  </p>
  <p>
    A conforming JSON-LD processor implementing RDF conversion <em class="rfc2119" title="must">must</em> implement a
    processing algorithm that results in the same set of RDF <a class="datatype idlType" title="quad" href="#idl-def-quad"><code>Quads</code></a> that the following
    algorithm generates:
  </p>

  <p>The algorithm takes five input variables: a <em>element</em> to be converted, an
    <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>, <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> and <a class="tref internalDFN" title="graph_name" href="#dfn-graph_name">graph name</a>.
    To begin, the <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>, <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> and <a class="tref internalDFN" title="graph_name" href="#dfn-graph_name">graph name</a>
    are set to <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, and <em>element</em> is
    set to the result of performing the <a href="#expansion-algorithm">Expansion Algorithm</a> on
    the <a class="tref internalDFN" title="json-ld_input" href="#dfn-json-ld_input">JSON-LD input</a>. This removes any existing context to allow the given context to be cleanly
    applied.</p>

  <ol class="algorithm">
    <li id="processing-step-associative">
      If <em>element</em> is a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a>, perform the following steps:
      <ol class="algorithm">
        <li>Set <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> to <a class="tref internalDFN" title="null" href="#dfn-null">null</a>.</li>
        <li>
          If <em>element</em> has a <code>@value</code> property:
          <ol class="algorithm">
            <li>If the value of <code>@value</code> is a <a class="tref internalDFN" title="number" href="#dfn-number">number</a>, set the
              <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> to a <a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">typed literal</a> using a string representation
              of the value as defined in the section <a href="#data-round-tripping">Data Round Tripping</a>.
              Set datatype to the value of the <code>@type</code> property if it exists, otherwise
              either <code>xsd:integer</code> or <code>xsd:double</code>, depending
              on if the value contains a fractional and/or an exponential component.</li>
            <li>Otherwise, if the value of <code>@value</code> is <strong>true</strong> or <strong>false</strong>,
              set the <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> to a <a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">typed literal</a> created from the
              string representation of the value. Set datatype to the value of the <code>@type</code>
              property if it exists, otherwise <code>xsd:boolean</code>.</li>
            <li>
              Otherwise, if <em>element</em> contains a <code>@type</code> property, set the
              <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> to a <a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">typed literal</a>.
            </li>
            <li>
              Otherwise, set the <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> to a <a class="tref internalDFN" title="plain_literal" href="#dfn-plain_literal">plain literal</a>. If <em>element</em>
              contains a <code>@language</code> property, use its value to set the language of the plain literal.
            </li>
          </ol>
        </li>
        <li>
          If <em>element</em> has a <code>@list</code> property the value <em class="rfc2119" title="must">must</em> be an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>.
          Process its value as a list as described in <a href="#list-conversion">List Conversion</a> using
          the return value as the <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a>
        </li>
        <li>If <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> is not <a class="tref internalDFN" title="null" href="#dfn-null">null</a>:
          <ol class="algorithm">
            <li>If neither <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a> nor <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> are <a class="tref internalDFN" title="null" href="#dfn-null">null</a>,
              generate a <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a>
              representing <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>, <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>,
              <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a>, and <a class="tref internalDFN" title="graph_name" href="#dfn-graph_name">graph name</a>.</li>
            <li>Return <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a>.</li>
          </ol>
        </li>
        <li id="processing-step-subject">If <em>element</em> has a <code>@id</code> property,
          the value <em class="rfc2119" title="must">must</em> be a <a class="tref internalDFN" title="string" href="#dfn-string">string</a>, set the <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a> to the previously
          expanded value (either a <a href="#idl-def-BlankNode" class="idlType"><code>BlankNode</code></a> or an <a class="datatype idlType" title="IRI" href="#idl-def-IRI"><code><abbr title="Internationalized Resource Identifier">IRI</abbr></code></a>).</li>
        <li>
          Otherwise, if <em>element</em> does not have a <code>@id</code> property, set the <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active
          subject</a> to newly generated <a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">blank node</a>.</li>
        <li>
          Process each <em>property</em> and <em>value</em> in <em>element</em>, ordered by
          <em>property</em>, as follows:
          <ol class="algorithm">
            <li>
              If <em>property</em> is <code>@type</code>, set the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>
              to <code>rdf:type</code>.
            </li>
            <li>Otherwise, if <em>property</em> is <code>@graph</code>,
              process <em>value</em> algorithm recursively, using <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a> as <a class="tref internalDFN" title="graph_name" href="#dfn-graph_name">graph name</a>
              and null values for <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a> and <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> and then
              proceed to next property.</li>
            <li>Otherwise, if <em>property</em> is a <a class="tref internalDFN" title="keyword" href="#dfn-keyword">keyword</a>, skip this step.</li>
            <li>Otherwise, set <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> to the <abbr title="Internationalized Resource Identifier">IRI</abbr> value of <em>property</em>.</li>
            <li>Process <em>value</em> recursively using this algorithm, passing copies of
              <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>, <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> and <a class="tref internalDFN" title="graph_name" href="#dfn-graph_name">graph name</a>.
            </li>
          </ol>
        </li>
        <li>
          Set <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> to <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>.
        </li>
      </ol>
    </li>

    <li>Otherwise, if <em>element</em> is an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, process each value in the <a class="tref internalDFN" title="array" href="#dfn-array">array</a>
      as follows, process <em>element</em> recursively using this algorithm, using copies of
      <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>, <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>, and <a class="tref internalDFN" title="graph_name" href="#dfn-graph_name">graph name</a>.</li>

    <li>Otherwise, if <em>element</em> is a <a class="tref internalDFN" title="string" href="#dfn-string">string</a>, then the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>
      must be <code>rdf:type</code> so set the <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> to an <a class="datatype idlType" title="IRI" href="#idl-def-IRI"><code><abbr title="Internationalized Resource Identifier">IRI</abbr></code></a>.</li>

    <li>If any of these steps created an <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> and neither <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>
      nor <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> are <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, generate a <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a> using
      <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>,<a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>, <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> and
      <a class="tref internalDFN" title="graph_name" href="#dfn-graph_name">graph name</a>.
    </li>
    <li>Return <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a>.</li>
  </ol>
</div>
<div id="list-conversion" typeof="bibo:Chapter" resource="#list-conversion" rel="bibo:chapter" class="section">
  <h4><span class="secno">3.13.4 </span>List Conversion</h4>

  <p>List Conversion is the process of taking an <a class="tref internalDFN" title="array" href="#dfn-array">array</a> of values and adding them to a newly
    created <cite><a href="http://www.w3.org/TR/rdf-schema/#ch_collectionvocab">RDF Collection</a></cite> (see
    [<cite><a class="bibref" rel="biblioentry" href="#bib-RDF-SCHEMA">RDF-SCHEMA</a></cite>]) by linking each element of the list using <code>rdf:first</code> and <code>rdf:next</code>,
    terminating the list with <code>rdf:nil</code> using the following sequence:</p>
  <p>The algorithm is invoked with an <a class="tref internalDFN" title="array" href="#dfn-array">array</a> <em>array</em>, the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>
    and returns a value to be used as an <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> in the calling location.</p>
  <div class="note">This algorithm does not support lists containing lists.</div>
  <ol class="algorithm">
    <li>
      If <em>array</em> is empty return <code>rdf:nil</code>.
    </li>
    <li>
      Otherwise, generate a <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a> using using the <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>, <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>
      and a newly generated <a href="#idl-def-BlankNode" class="idlType"><code>BlankNode</code></a> identified as <em>first <a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">blank node</a></em>.
    </li>
    <li>
      For each element in <em>array</em> other than the last element:
      <ol class="algorithm">
        <li>Create a processor state using
          <em>first blank node</em> as the <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>, and
          <code>rdf:first</code> as the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>.
          <ol class="algorithm">
            <li>Process the value starting at <a href="#processing-step-associative">Step 1</a>.</li>
            <li>Proceed using the previous <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a>.</li>
          </ol>
        </li>
        <li>Unless this is the last element in <em>array</em>, generate a new <a href="#idl-def-BlankNode" class="idlType"><code>BlankNode</code></a> identified as
          <em>rest blank node</em>, otherwise use <code>rdf:nil</code>.</li>
        <li>Generate a new <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a> using <em>first blank node</em>,
          <code>rdf:rest</code> and <em>rest blank node</em>.</li>
        <li>Set <em>first blank node</em> to
          <em>rest blank node</em>.</li>
        <li>Return <em>first blank node</em>.</li>
      </ol>
    </li>
  </ol>
</div>

<div id="convert-from-rdf-algorithm" typeof="bibo:Chapter" resource="#convert-from-rdf-algorithm" rel="bibo:chapter" class="section">
  <h4><span class="secno">3.13.5 </span>Convert from RDF Algorithm</h4>
  <p>In some cases, data exists natively in Triples or Quads form; for example, if the data was originally
    represented in an RDF graph or triple/quad store. This algorithm is designed to simply translate
    an array of <a class="datatype idlType" title="quad" href="#idl-def-quad"><code>Quads</code></a> into a JSON-LD document.</p>
  <p>The conversion algorithm takes a single parameter <em>input</em> in the form of an
    array of <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a> representations.</p>
  <ol class="algorithm">
    <li id="new_graph">Construct <em>defaultGraph</em> as a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a>
      containing <em>subjects</em> and <em>listMap</em>,each an empty <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a>.</li>
    <li>Construct <em>graphs</em> as a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> containing <em>defaultGraph</em>
      identified by
      an empty <a class="tref internalDFN" title="string" href="#dfn-string">string</a>.</li>
    <li>For each quad in <em>input</em>:
      <ol class="algorithm">
        <li>Set <em>graph</em> to the entry in <em>graphs</em> identified
          by <em>name</em>, initializing it to a new entry using the mechanism
          described in <a href="#new_graph">Step 1</a>.</li>
        <li>If <em>property</em> is <code>rdf:first</code>,
          use the entry in <em>graph.listMap</em> indexed by <em>subject</em>,
          initializing it to a new <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> if nesessary. Represent
          <em>object</em> in expanded form, as described in
          <a href="#value-expansion">Value Expansion</a>. Add the
          resulting <em>object representation</em> to the entry indexed by
          <em>first</em>, and skip to the next quad.</li>
        <li>If <em>property</em> is <code>rdf:rest</code>:
          <ol class="algorithm">
            <li>If <em>object</em> is a <a href="#idl-def-BlankNode" class="idlType"><code>BlankNode</code></a>, use the entry in
              <em>graph.listMap</em> indexed by <em>subject</em>, initializing it
              to a new <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> if necessary. Add the <em>nominalValue</em> of
              <em>object</em> to the entry indexed by <em>rest</em>.
            </li>
            <li>Skip to the next quad.</li>
          </ol>
        </li>
        <li>If <em>name</em> is not <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, and <em>defaultGraph.subjects</em>
          does not contain an entry for <em>name</em>,
          create a new entry for <em>name</em> from a new
          <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> with key/value pair of <code>@id</code> and
          a string representation of <em>name</em>.</li>
        <li>Set <em>value</em> as the entry from <em>graph.subjects</em> for
          <em>subject</em>, initializing it to a new
          <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> with key/value pair of <code>@id</code> and
          a string representation of <em>subject</em> if necessary.</li>
        <li>If <em>property</em> is <code>rdf:type</code> and the <em>notType</em>
          option is present and not <a class="tref internalDFN" title="true" href="#dfn-true">true</a>:
          <ol class="algorithm">
            <li>Append the string representation of <em>object</em> to the array value for the
              key <code>@type</code>, creating an entry in <em>value</em> if necessary.</li>
          </ol>
        </li>
        <li>Otherwise, if <em>object</em> is <code>rdf:nil</code>:
          <ol class="algorithm">
            <li>Let <em>key</em> be the string representation of <em>property</em>.</li>
            <li>Append an empty <code>@list</code> representation to the array value for
              <em>key</em>, creating an entry in <em>value</em> if necessary.</li>
          </ol>
        </li>
        <li>Otherwise,
          <ol class="algorithm">
            <li>Let <em>key</em> be the string representation of <em>property</em> and let
              <em>object representation</em>
              be <em>object</em> represented in expanded form as described in
              <a href="#value-expansion">Value Expansion</a>.</li>
            <li>If <em>object</em> is a <a href="#idl-def-BlankNode" class="idlType"><code>BlankNode</code></a>,
              use the entry in <em>graph.listMap</em> indexed by <em>object</em>,
              initializing it to a new <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> if nesessary.
              Add an entry for <em>head</em> with <em>object representation</em>.</li>
            <li>Append <em>object representation</em> to the array value for
              <em>key</em>, creating an entry in <em>value</em> if necessary.</li>
          </ol>
        </li>
      </ol>
    </li>
    <li>For each <em>name</em> and <em>graph</em> in <em>graphs</em>:
      <ol class="algorithm">
        <li>For each <em>subject</em> and <em>entry</em> in <em>graph</em>
          where <em>entry</em> has both <em>head</em> and <em>first</em> keys:
          <ol class="algorithm">
            <li>Set <em>value</em> to the value of <em>head</em> in <em>entry</em>.</li>
            <li>Remove the entry for <code>@id</code> in <em>value</em>.</li>
            <li>Add an entry to <em>value</em> for <code>@list</code> initialized to a new array
              containing the value of <em>first</em> from <em>entry</em>.</li>
            <li>While <em>entry</em> has a key for <em>rest</em>:
              <ol class="algorithm">
                <li>Set <em>entry</em> to the value of <em>graph.listMap</em> for <em>entry.rest</em>.</li>
                <li>Add the value for <em>entry.first</em> to the list array.</li>
              </ol>
            </li>
          </ol>
        </li>
      </ol>
    </li>
    <li>Create <em>array</em> as an empty <a class="tref internalDFN" title="array" href="#dfn-array">array</a>.</li>
    <li>For each <em>subject</em> and <em>entry</em> in <em>defaultGraph.subjects</em>
      ordered by <em>subject</em>:
      <ol class="algorithm">
        <li>Add <em>entry</em> to <em>array</em>.</li>
        <li>If <em>graphs</em> has an entry for <em>subject</em>, add a property
          <code>@graph</code> in <em>entry</em> containing the ordered entries
          from <em>graphs[subject].subjects</em>.</li>
      </ol>
    </li>
    <li>Return <em>array</em> as the result.</li>
  </ol>
</div>
</div>

</div>

<div id="data-round-tripping" typeof="bibo:Chapter" resource="#data-round-tripping" rel="bibo:chapter" class="section">

<!-- OddPage -->
<h2><span class="secno">4. </span>Data Round Tripping</h2>

<p>When coercing numbers to <strong>xsd:integer</strong> or <strong>xsd:double</strong>
  as it, e.g., happens during <a href="#rdf-conversion">RDF Conversion</a>, implementers <em class="rfc2119" title="must">must</em>
  ensure that the result is a canonical lexical representation in the form of a
  <a class="tref internalDFN" title="string" href="#dfn-string">string</a>. A <dfn title="canonical_lexical_representation" id="dfn-canonical_lexical_representation">canonical lexical representation</dfn> is a set of literals
  from among the valid set of literals for a datatype such that there is a one-to-one mapping
  between the canonical lexical representation and a value in the value space as defined in
  [<cite><a class="bibref" rel="biblioentry" href="#bib-XMLSCHEMA-2">XMLSCHEMA-2</a></cite>]. In other words, every value <em class="rfc2119" title="must">must</em> be converted to a deterministic string
  representation.</p>
<p>The canonical lexical representation of an <em>integer</em>, i.e., a number without fractions
  or a number coerced to <strong>xsd:integer</strong>, is a finite-length sequence of decimal
  digits (<code>0-9</code>) with an optional leading minus sign; leading zeroes are prohibited.
  To convert the number in JavaScript, implementers can use the following snippet of code:</p>
<pre class="example">(value).toFixed(0).toString()</pre>
<p>The canonical lexical representation of a <em>double</em>, i.e., a number with fractions
  or a number coerced to <strong>xsd:double</strong>, consists of a mantissa followed by the
  character &quot;E&quot;, followed by an exponent. The mantissa <em class="rfc2119" title="must">must</em> be a decimal number. The exponent
  <em class="rfc2119" title="must">must</em> be an integer. Leading zeroes and a preceding plus sign (<code>+</code>) are prohibited
  in the exponent. If the exponent is zero, it must be indicated by <code>E0</code>.
  For the mantissa, the preceding optional plus sign is prohibited and the decimal point is
  required. Leading and trailing zeroes are prohibited subject to the following: number
  representations must be normalized such that there is a single digit which is non-zero to the
  left of the decimal point and at least a single digit to the right of the decimal point unless
  the value being represented is zero. The canonical representation for zero is <code>0.0E0</code>.
  To convert the number in JavaScript, implementers can use the following snippet of code:</p>
<pre class="example">(value).toExponential().replace(/e\+?/,'E')</pre>
<p><strong>xsd:double</strong>'s value space is defined by the IEEE double-precision 64-bit
floating point type [<cite><a class="bibref" rel="biblioentry" href="#bib-IEEE-754-1985">IEEE-754-1985</a></cite>].</p>

<p class="note">When data such as decimals need to be normalized, JSON-LD authors should
not use values that are going to undergo automatic conversion. This is due to the lossy nature
of <strong>xsd:double</strong> values. Authors should instead use the expanded object form to
set the canonical lexical representation directly.</p>

<p class="note">When JSON-native datatypes, like <a class="tref internalDFN" title="number" href="#dfn-number">number</a>s, are type coerced, lossless
data round-tripping can not be guaranted. Consider the following code example:</p>

<pre class="example">var myObj1 = {
               &quot;@context&quot;: {
                 &quot;number&quot;: {
                   &quot;@id&quot;: &quot;http://example.com/vocab#number&quot;,
                   <span class="diff">&quot;@type&quot;: &quot;xsd:nonNegativeInteger&quot;</span>
                 }
               },
               &quot;number&quot; : <span class="diff">42</span>
             };

// Convert the JSON-LD document to RDF; this converts 42 to a string
var jsonldText = jsonld.toRDF(myObj1, myRdfTripleCollector);

// Convert the RDF triples back to a JavaScript object
var myObj2 = jsonld.fromRDF(myRdfTripleCollector.getTriples());</pre>

<p>At this point, <code>myObj1</code> and <code>myObj2</code> will have different
  values for the &quot;number&quot; property. <code>myObj1</code> will have the number
  <code>42</code>, while <code>myObj2</code> have an object consisting of
  <code>@value</code> set to the string <code>&quot;42&quot;</code> and <code>@type</code>
  set to the expanded value of <em>xsd:nonNegativeInteger</em>.</p>

<p class="note">Some JSON serializers, such as PHP's native implementation in some versions,
  backslash-escape the forward slash character. For example, the value
  <code>http://example.com/</code> would be serialized as <code>http:\/\/example.com\/</code>.
  This is problematic as other JSON parsers might not understand those escaping characters.
  There is no need to backslash-escape forward slashes in JSON-LD. To aid interoperability
  between JSON-LD processors, a JSON-LD serializer <em class="rfc2119" title="must not">must not</em> backslash-escape forward slashes.</p>

</div>

<div class="appendix informative section" id="iana-considerations" typeof="bibo:Chapter" resource="#iana-considerations" rel="bibo:chapter">

<!-- OddPage -->
<h2><span class="secno">A. </span>IANA Considerations</h2><p><em>This section is non-normative.</em></p>

<p>This section is included merely for standards community review and will be
submitted to the Internet Engineering Steering Group if this specification
becomes a W3C Recommendation.</p>

<h3 id="application-ld-frame-json">application/ld-frame+json</h3>
<dl>
  <dt>Type name:</dt>
  <dd>application</dd>
  <dt>Subtype name:</dt>
  <dd>ld-frame+json</dd>
  <dt>Required parameters:</dt>
  <dd>None</dd>
  <dt>Optional parameters:</dt>
  <dd>None</dd>
  <dt>Encoding considerations:</dt>
  <dd>The same as the <code>application/json</code> MIME media type.</dd>
  <dt>Security considerations:</dt>
  <dd>Since a JSON-LD frame is intended to specify a deterministic layout
    for a JSON-LD graph, the serialization <em class="rfc2119" title="should not">should not</em> be passed through a
    code execution mechanism such as JavaScript's <code>eval()</code>
    function. It is <em class="rfc2119" title="recommended">recommended</em> that a conforming parser does not attempt to
    directly evaluate the JSON-LD frame and instead purely parse the
    input into a language-native data structure.</dd>
  <dt>Interoperability considerations:</dt>
  <dd>Not Applicable</dd>
  <dt>Published specification:</dt>
  <dd>The <a href="http://json-ld.org/spec/latest/">JSON-LD</a> specification.</dd>
  <dt>Applications that use this media type:</dt>
  <dd>Any programming environment that requires the exchange of
    directed graphs. Implementations of JSON-LD have been created for
    JavaScript, Python, Ruby, PHP and C++.
  </dd>
  <dt>Additional information:</dt>
  <dd>
    <dl>
      <dt>Magic number(s):</dt>
      <dd>Not Applicable</dd>
      <dt>File extension(s):</dt>
      <dd>.jsonldf</dd>
      <dt>Macintosh file type code(s):</dt>
      <dd>TEXT</dd>
    </dl>
  </dd>
  <dt>Person &amp; email address to contact for further information:</dt>
  <dd>Manu Sporny &lt;msporny@digitalbazaar.com&gt;</dd>
  <dt>Intended usage:</dt>
  <dd>Common</dd>
  <dt>Restrictions on usage:</dt>
  <dd>None</dd>
  <dt>Author(s):</dt>
  <dd>Manu Sporny, Gregg Kellogg, Markus Lanthaler, Dave Longley</dd>
  <dt>Change controller:</dt>
  <dd>W3C</dd>
</dl>

<p>Fragment identifiers have no meaning with
  <a href="#application-ld-frame-json">application/frame-ld+json</a> resources.</p>

</div>

<div class="appendix section" id="appendix-b" typeof="bibo:Chapter" resource="#appendix-b" rel="bibo:chapter">
  
<!-- OddPage -->
<h2><span class="secno">B. </span>Initial Context</h2>
  <p>The <a class="tref internalDFN" title="initial_context" href="#dfn-initial_context">initial context</a> is defined with the following default entries:</p>
<pre class="example">{
  &quot;@context&quot;: {
    &quot;http://www.w3.org/1999/02/22-rdf-syntax-ns#type&quot;: { &quot;@type&quot;: &quot;@id&quot;}
  }
}</pre>
  <p>Processors <em class="rfc2119" title="must">must</em> act as if the initial context is defined in the outer-most level when processing
    JSON-LD documents.</p>
  <p class="issue">Should we define other default prefixes?</p>
</div>

<div class="appendix section" id="acknowledgements" typeof="bibo:Chapter" resource="#acknowledgements" rel="bibo:chapter">

<!-- OddPage -->
<h2><span class="secno">C. </span>Acknowledgements</h2>

<p>The editors would like to thank Mark Birbeck, who provided a great deal of
the initial push behind the JSON-LD work via his work on RDFj,
Dave Lehn and Mike Johnson who reviewed, provided feedback, and
performed several implementations of the specification, and Ian Davis, who
created RDF/JSON. Thanks also to Nathan Rixham, Bradley P. Allen,
Kingsley Idehen, Glenn McDonald, Alexandre Passant, Danny Ayers, Ted
Thibodeau Jr., Olivier Grisel, Niklas Lindström, Markus Lanthaler, and Richard
Cyganiak for their input on the specification.
</p>
</div>



<div id="references" class="appendix section" typeof="bibo:Chapter" resource="#references" rel="bibo:chapter">
<!-- OddPage -->
<h2><span class="secno">D. </span>References</h2><div id="normative-references" typeof="bibo:Chapter" resource="#normative-references" rel="bibo:chapter" class="section"><h3><span class="secno">D.1 </span>Normative references</h3><dl class="bibliography" about=""><dt id="bib-BCP47">[BCP47]</dt><dd rel="dcterms:requires">A. Phillips, M. Davis. <a href="http://tools.ietf.org/rfc/bcp/bcp47.txt"><cite>Tags for Identifying Languages</cite></a> September 2009. IETF Best Current Practice. URL: <a href="http://tools.ietf.org/rfc/bcp/bcp47.txt">http://tools.ietf.org/rfc/bcp/bcp47.txt</a>
</dd><dt id="bib-IEEE-754-1985">[IEEE-754-1985]</dt><dd rel="dcterms:requires">IEEE. <cite>IEEE Standard for Binary Floating-Point Arithmetic.</cite> See <a href="http://standards.ieee.org/reading/ieee/std_public/description/busarch/754-1985_desc.html">http://standards.ieee.org/reading/ieee/std_public/description/busarch/754-1985_desc.html</a>
</dd><dt id="bib-IRI">[IRI]</dt><dd rel="dcterms:requires">M. Duerst, M. Suignard. <a href="http://www.ietf.org/rfc/rfc3987.txt"><cite>Internationalized Resource Identifiers (IRI).</cite></a> January 2005. Internet RFC 3987. URL: <a href="http://www.ietf.org/rfc/rfc3986.txt">http://www.ietf.org/rfc/rfc3987.txt</a> 
</dd><dt id="bib-JSON-LD">[JSON-LD]</dt><dd rel="dcterms:requires">Manu Sporny, Gregg Kellogg, Markus Lanthaler. <a href="http://json-ld.org/spec/latest/json-ld-syntax/"><cite>The JSON-LD Syntax</cite></a> Latest. W3C Editor's Draft. URL: <a href="http://json-ld.org/spec/latest/json-ld-syntax/">http://json-ld.org/spec/latest/json-ld-syntax/</a>
</dd><dt id="bib-JSON-POINTER">[JSON-POINTER]</dt><dd rel="dcterms:requires">P. Bryan, Ed. <cite><a href="http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-01">JSON Pointer</a></cite> Latest. IETF Draft. URL: <a href="http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-01">http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-01</a>
</dd><dt id="bib-RDF-CONCEPTS">[RDF-CONCEPTS]</dt><dd rel="dcterms:requires">Graham Klyne; Jeremy J. Carroll. <a href="http://www.w3.org/TR/2004/REC-rdf-concepts-20040210"><cite>Resource Description Framework (RDF): Concepts and Abstract Syntax.</cite></a> 10 February 2004. W3C Recommendation. URL: <a href="http://www.w3.org/TR/2004/REC-rdf-concepts-20040210">http://www.w3.org/TR/2004/REC-rdf-concepts-20040210</a> 
</dd><dt id="bib-RDF-SCHEMA">[RDF-SCHEMA]</dt><dd rel="dcterms:requires">Dan Brickley; Ramanathan V. Guha. <a href="http://www.w3.org/TR/2004/REC-rdf-schema-20040210"><cite>RDF Vocabulary Description Language 1.0: RDF Schema.</cite></a> 10 February 2004. W3C Recommendation. URL: <a href="http://www.w3.org/TR/2004/REC-rdf-schema-20040210">http://www.w3.org/TR/2004/REC-rdf-schema-20040210</a> 
</dd><dt id="bib-RFC3986">[RFC3986]</dt><dd rel="dcterms:requires">T. Berners-Lee; R. Fielding; L. Masinter. <a href="http://www.ietf.org/rfc/rfc3986.txt"><cite>Uniform Resource Identifier (URI): Generic Syntax.</cite></a> January 2005. Internet RFC 3986. URL: <a href="http://www.ietf.org/rfc/rfc3986.txt">http://www.ietf.org/rfc/rfc3986.txt</a> 
</dd><dt id="bib-RFC3987">[RFC3987]</dt><dd rel="dcterms:requires">M. Dürst; M. Suignard. <a href="http://www.ietf.org/rfc/rfc3987.txt"><cite>Internationalized Resource Identifiers (IRIs).</cite></a> January 2005. Internet RFC 3987. URL: <a href="http://www.ietf.org/rfc/rfc3987.txt">http://www.ietf.org/rfc/rfc3987.txt</a> 
</dd><dt id="bib-RFC4627">[RFC4627]</dt><dd rel="dcterms:requires">D. Crockford. <a href="http://www.ietf.org/rfc/rfc4627.txt"><cite>The application/json Media Type for JavaScript Object Notation (JSON)</cite></a> July 2006. Internet RFC 4627. URL: <a href="http://www.ietf.org/rfc/rfc4627.txt">http://www.ietf.org/rfc/rfc4627.txt</a>
</dd><dt id="bib-WEBIDL">[WEBIDL]</dt><dd rel="dcterms:requires">Cameron McCormack. <a href="http://www.w3.org/TR/2011/WD-WebIDL-20110927/"><cite>Web IDL.</cite></a> 27 September 2011. W3C Working Draft. (Work in progress.) URL: <a href="http://www.w3.org/TR/2011/WD-WebIDL-20110927/">http://www.w3.org/TR/2011/WD-WebIDL-20110927/</a> 
</dd><dt id="bib-XMLSCHEMA-2">[XMLSCHEMA-2]</dt><dd rel="dcterms:requires">Paul V. Biron; Ashok Malhotra. <a href="http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/"><cite>XML Schema Part 2: Datatypes Second Edition.</cite></a> 28 October 2004. W3C Recommendation. URL: <a href="http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/">http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/</a> 
</dd></dl></div><div id="informative-references" typeof="bibo:Chapter" resource="#informative-references" rel="bibo:chapter" class="section"><h3><span class="secno">D.2 </span>Informative references</h3><dl class="bibliography" about=""><dt id="bib-ECMA-262">[ECMA-262]</dt><dd rel="dcterms:references"><a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm"><cite>ECMAScript Language Specification.</cite></a> December 1999. URL: <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">http://www.ecma-international.org/publications/standards/Ecma-262.htm</a> 
</dd><dt id="bib-MICRODATA">[MICRODATA]</dt><dd rel="dcterms:references">Ian Hickson; et al. <a href="http://www.w3.org/TR/microdata/"><cite>Microdata</cite></a> 04 March 2010. W3C Working Draft. URL: <a href="http://www.w3.org/TR/microdata/">http://www.w3.org/TR/microdata/</a> 
</dd><dt id="bib-MICROFORMATS">[MICROFORMATS]</dt><dd rel="dcterms:references"><a href="http://microformats.org"><cite>Microformats</cite></a>. URL: <a href="http://microformats.org">http://microformats.org</a> 
</dd><dt id="bib-RDFA-CORE">[RDFA-CORE]</dt><dd rel="dcterms:references">Shane McCarron; et al. <a href="http://www.w3.org/TR/2012/PR-rdfa-core-20120508/"><cite>RDFa Core 1.1: Syntax and processing rules for embedding RDF through attributes.</cite></a> 8 May 2012. W3C Proposed Recommendation. URL: <a href="http://www.w3.org/TR/2012/PR-rdfa-core-20120508/">http://www.w3.org/TR/2012/PR-rdfa-core-20120508/</a> 
</dd></dl></div></div></body></html>
